关于线程开启的两种方式

第一种方式,继承Thread类

 1 public class Thread extends java.lang.Thread {
 2
 3     private String name;
 4
 5     // 定义run方法
 6     public void run() {
 7         for (int i = 0; i < 20; i++) {
 8             System.out.println(name + "haha");
 9         }
10     }
11
12     // 构造函数重写构(无参)
13     public Thread() {
14
15     }
16
17     // 有参数的构造函数
18     public Thread(String name) {
19
20         this.name = name;
21     }
22
23     public static void main(String[] args) {
24
25         Thread t1 = new Thread("T1");
26         Thread t2 = new Thread("T2");
27
28         t1.start();
29         t2.start();
30
31     }
32
33 }

运行结果

 1 T1haha
 2 T1haha
 3 T1haha
 4 T1haha
 5 T1haha
 6 T2haha
 7 T2haha
 8 T2haha
 9 T2haha
10 T2haha
11 T2haha
12 T2haha
13 T2haha
14 T2haha
15 T2haha
16 T2haha
17 T2haha
18 T2haha
19 T2haha
20 T2haha
21 T2haha
22 T2haha
23 T2haha
24 T2haha
25 T2haha
26 T1haha
27 T1haha
28 T1haha
29 T1haha

这种方式继承Thread类,直接通过Thread开启,这个run方法只是线程开启类内部自己调用,并不是用线程调用的也就是说线程的开启并不是Thread.run()

第二种方式实现Runnable 接口,实现这个接口会自动重写run方法
 1 public class Hello implements Runnable {
 2
 3     private String name;
 4
 5     // 定义run方法
 6     public void run() {
 7         for (int i = 0; i < 20; i++) {
 8             System.out.println(name + "haha");
 9         }
10     }
11
12     // 构造函数重写构(无参)
13     public Hello() {
14
15     }
16
17     // 有参数的构造函数
18     public Hello(String name) {
19
20         this.name = name;
21     }
22
23     public static void main(String[] args) {
24
25         Hello h1 = new Hello("h1");
26         Thread t1 = new Thread(h1);
27         Hello h2 = new Hello("h2");
28         Thread t2 = new Thread(h2);
29         t1.start();
30         t2.start();
31
32     }
33
34 }

运行结果

 1 h2haha
 2 h1haha
 3 h2haha
 4 h1haha
 5 h2haha
 6 h1haha
 7 h2haha
 8 h1haha
 9 h2haha
10 h1haha
11 h2haha
12 h1haha
13 h2haha
14 h1haha
15 h2haha
16 h1haha
17 h2haha
18 h1haha
19 h2haha
20 h1haha
21 h2haha
22 h1haha
23 h2haha
24 h1haha
25 h2haha
26 h1haha
27 h2haha
28 h1haha
29 h2haha
30 h1haha
31 h2haha
32 h1haha
33 h2haha
34 h1haha
35 h2haha
36 h1haha
37 h2haha
38 h1haha
39 h2haha
40 h1haha

这种方式也开启成功

总结:这两种方式都可以开启线程,区别是,一个实现接口,一个继承Thread类,一般都去实现接口,有两点好处:1,实现接口的run方法类可以帮你构造出来 2,Java支持单继承,但可以实现多个接口。个人想法:Thread类就好比是一个载体,都可以用,继承Thread就是直接使用,而runnable接口就相当于在中间过渡一下,得自己创建类对象(这个类对象实现runnable接口),然后放到Thread载体上,Thread就可以自动调用run方法。(总结纯属个人观点)

				
时间: 2024-10-13 17:27:08

关于线程开启的两种方式的相关文章

Android 应用开发 之通过AsyncTask与ThreadPool(线程池)两种方式异步加载大量数据的分析与对比--转载

 在加载大量数据的时候,经常会用到异步加载,所谓异步加载,就是把耗时的工作放到子线程里执行,当数据加载完毕的时候再到主线程进行UI刷新.在数据量非常大的情况下,我们通常会使用两种技术来进行异步加载,一是通过AsyncTask来实现,另一种方式则是通过ThreadPool来实现,今天我们就通过一个例子来讲解和对比这两种实现方式.     项目的结构如下所示:     在今天这个例子里,我们用到了之前一篇文章中写过的一个自定义控件,如果有同学感兴趣的话可以点击这里来先研究下这个控件的实现,为了配合异

【线程实现的两种方式及区别】

我们来用最经典的卖票的案例,表明两种实现方式的区别,同时分析线程不安全产生的原因 一.继承Thread类 package test; /** * @Description * @Author shusheng * @Email [email protected] * @Date 2018/8/31 */ public class SellTicketOne extends Thread{ private static int tickets = 100; @Override public voi

Android更新主线程UI的两种方式handler与runOnUiThread()

在android开发过程中,耗时操作我们会放在子线程中去执行,而更新UI是要主线程(也叫做:UI线程)来更新的,自然会遇到如何更新主线程UI的问题.如果在主线程之外的线程中直接更新页面显示常会报错.抛出异常:android.view.ViewRoot.CalledFromWrongThreadException: Only the original thread that created a view hierarchy can touch its views. 为什么要有handler机制?h

Java中线程实现的两种方式例程

1. 继承Thread package com.sunplusedu; public class JavaTest {    public static void main(String args[]){        new MyThread().start();        int i = 10;        for(i = 10; i > 0; i--){            System.out.println("in the main "+i);         

c# 线程启动的两种方式与传参

1. ThreadPool.QueueUserWorkItem(new WaitCallback(writeProgramThread), xoinfo); 2. endThread = new Thread(new ParameterizedThreadStart(endRecordThread)); endThread.IsBackground = true; endThread.Start(nowrecordinfo); 不带参数 scanThread = new Thread(new T

【java并发】传统线程技术中创建线程的两种方式

传统的线程技术中有两种创建线程的方式:一是继承Thread类,并重写run()方法:二是实现Runnable接口,覆盖接口中的run()方法,并把Runnable接口的实现扔给Thread.这两种方式大部分人可能都知道,但是为什么这样玩就可以呢?下面我们来详细分析一下这两种方法的来龙去脉. 1. 揭秘Thread中run()方法 上面我们看到这两种方式都跟run()方法有关,所以我们来看一下Thread的源码中run()方法到底都干了什么: @Override public void run()

同一个请求分配一个traceId的两种方式

有时候我们需要某个请求下的所有的traceId都是一致的,以获得统一解析的日志文件.便于排查问题. 为每一个请求分配同一个traceId据我所知有两种方式:MDC和ThreadLocal,MDC的内部实现也是ThreadLocal,下面分别介绍这两种方式. 一.MDC MDC(Mapped Diagnostic Contexts),翻译过来就是:映射的诊断上下文.意思是:在日志中(映射的)请求ID(requestId),可以作为我们定位(诊断)问题的关键字(上下文). 有了MDC工具,只要在接口

Java开启线程的两种方式

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.ios培训..Net培训</a>.期待与您交流!------ Java开启线程的两种方式: 方式一:成为线程(Thread)的儿子,即继承Thread类简单代码如下:class Student extends Thread{Student(String name){super(name);}public

python并发编程:多线程-开启线程的两种方式

一 threading模块介绍 multiprocess模块完全模仿了threading模块的接口,二者在使用层面,有很大的相似性 二 开启线程的两种方式 方式一 from threading import Thread import time def sayhi(name): time.sleep(2) print("%s say hello" % name) if __name__ == '__main__': t = Thread(target=sayhi, args=('mik