一个问题
哈喽,我是狗哥。话不多说,金三银四,很多同学马上就要加入春招了。而多线程必定是面试必问的,开篇之前,问大家一个问题:创立线程到底有几种形式?
- 根底答案(答复谬误):两种,继承 Thread 和 实现 Runnable
- 进阶答案(答复谬误):多种,继承 Thread 、实现 Runnable、线程池创立、Callable 创立、Timer 创立等等
置信以上答案很多同学都能答出来。但它们都是谬误的,其实创立线程的形式只有一种。为什么?狗哥你丫逗我么?横看竖看,至多也得两种呀。别急,放下刀。且听我缓缓剖析:
第一种:继承 Thread
首先是继承 Thread,创立线程最经典的办法,这种办法很常见啦。刚入门的时候,狗哥写过不晓得多少遍了。它的写法是这样的:
public class MyThread extends Thread { @Override public void run() { System.out.println("通过集成 Thread 类实现线程"); }}// 如何应用new MyThread().start()
如代码所示:继承 Thread 类,并重写了其中的 run () 办法,之后间接调用 start() 即可实现多线程。置信下面这种形式你肯定十分相熟,并且常常在工作中应用它们。
第二种:实现 Runnable
也是最罕用的办法,写法如下:
public class MyRunnable implements Runnable { @Override public void run() { System.out.println("通过实现 Runnable 形式实现线程"); }}// 应用// 1、创立MyRunnable实例MyRunnable runnable = new MyRunnable();//2.创立Thread对象//3.将MyRunnable放入Thread实例中Thread thread = new Thread(runnable);//4.通过线程对象操作线程(运行、进行)thread.start();
如代码所示,这种办法其实是定义一个线程执行的工作(run 办法外面的逻辑)并没有创立线程。它首先通过 MyRunnable类实现 Runnable 接口,而后重写 run () 办法,之后还要把这个实现了 run () 办法的实例传到 Thread 类中才能够实现多线程。
第三种:线程池创立线程
说完这两种在工作中最罕用的,咱们再说说第三种。在 Java 中,咱们创立线程池是这样的:
// 10 是外围线程数量ExecutorService service = Executors.newFixedThreadPool(10);
点进去 newFixedThreadPool 源码,在 IDEA 中调试,能够发现它的调用链是这样的:
Executors.newFixedThreadPool(10) --> new ThreadPoolExecutor(一堆参数) --> Executors.defaultThreadFactory()
能够发现最终还是调用了 Executors.defaultThreadFactory()
办法,而这个办法的源码是这样的:
static class DefaultThreadFactory implements ThreadFactory { // 线程池序号 static final AtomicInteger poolNumber = new AtomicInteger(1); // 线程序号 final AtomicInteger threadNumber = new AtomicInteger(1); // 线程组 final ThreadGroup group; // 线程池前缀 final String namePrefix; DefaultThreadFactory() { SecurityManager s = System.getSecurityManager(); group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup(); namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-"; } /** * 重点办法 * @param r * @return */ @Override public Thread newThread(Runnable r) { Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0); // 是否是守护线程 if (t.isDaemon()) { t.setDaemon(false); } // 设置优先级 if (t.getPriority() != Thread.NORM_PRIORITY) { t.setPriority(Thread.NORM_PRIORITY); } return t; }}
如上源码所示:线程池创立线程实质上是默认通过 DefaultThreadFactory
线程工厂来创立的。它能够设置线程的一些属性,比方:是否守护线程、优先级、线程名、等等。
但无论怎么设置,最终它还是须要通过 new Thread () 创立线程的。所以线程池创立线程并没有脱离以上的两种根本的创立形式。
第四种:Callable 创立
第四种是有返回值的 Callable 创立线程,用法是这样的:
public class MyCallable implements Callable<Integer> { @Override public Integer call() throws Exception { return new Random().nextInt(); } // 应用办法 // 1、创立线程池 ExecutorService service = Executors.newFixedThreadPool(10); // 2、提交工作,并用 Future提交返回后果 Future< Integer > future = service.submit(new MyCallable());}
Callable 与 Runnable 名字还有点像,区别在于 Runnable 是无返回值的。它们的实质都是定义线程要做的工作(call 或 run 办法外面的逻辑),而不是说他们自身就是线程。但无论有无返回值,它们都是须要被线程执行。
如代码所示,它们能够提交到线程池执行,通过 sumbit 办法提交。这时就参考形式三,由线程工厂负责创立线程。当然,还有其余办法执行 Callable 工作。然而不管怎么说,它还是离不开实现 Runnable 接口和继承 Thread 类这两种形式。
第五种:Timer 创立
咱们应用 Timer 的形式如下:
public class MyTimer { public static void main(String[] args) { timer(); } /** * 指定工夫 time 执行 schedule(TimerTask task, Date time) */ public static void timer() { Timer timer = new Timer(); // 设定指定的工夫time,此处为2000毫秒 timer.schedule(new TimerTask() { public void run() { System.out.println("执行定时工作"); } }, 2000); }}
如代码所示,Timer 定时器在两秒之后执行一些工作,它也的确创立了线程,然而深刻源码:
private final TimerThread thread = new TimerThread(queue);public Timer() { this("Timer-" + serialNumber());}public Timer(String name) { thread.setName(name); thread.start();}class TimerThread extends Thread { // 省略外部办法}
留神到 TimerThread ,它还是继承于 Thread ,所以 Timer 创立线程最初又绕回到最开始说的两种形式了。
为什么只有一种形式?
有同学可能说,狗哥你这扯半天不还是两种形式么?我答对了呀。。。别急,容我喝口水,上面剖析为何说它是一种?
留神到 Thread 类中有一个 run 办法:
private Runnable target;@Overridepublic void run() { if (target != null) { target.run(); }}
先看实现 Runnable 形式,它启动线程还是须要调用 start 办法(因为是 Native 办法咱们看不到具体逻辑),然而线程要执行工作必须还是要调用 run 办法(不然线程执行的是啥?)。
咱们看代码,run 办法非常简单。它判断 target 不为 null 就间接执行 target 的 run 办法。而 target 正是咱们实现的 Runnable ,应用 Runnable 接口实现线程时传给 Thread 类的对象。
在看继承 Thread 形式,它调用 thread.start(),最终调用的还是 run 办法(run() 外面是工作)。只不过这个 run() 是咱们曾经重写的 run() 而不是下面 Runnable(target) 的 run()。
看到这里可算明确了,事实上创立线程实质只有一种形式,就是结构一个 Thread 类,这是创立线程的惟一形式,不同的只是 run 办法(执行内容)的实现形式。
工作的起源
1、2 两种形式它们的不同点仅仅在于实现线程执行内容的不同,那么运行内容来自于哪里呢?
实质上,实现线程只有一种形式,而要想实现线程执行的内容,却有两种写法:
- 实现 Runnable 接口从而实现 run() 的形式
- 继承 Thread 类重写 run () 办法的形式
而后把咱们想要执行的代码传入,让线程去执行。在此基础上,如果咱们还想有更多实现线程的形式,比方线程池、Callable 以及 Timer 定时器,只须要在此基础上进行封装即可。
哪种写法好?
答案是:Runnable 写法。
理由:
- 易于扩大
这个不多说,Java 是单继承。如果应用继承 Thread 的写法。将不利于后续扩大。
- 解耦
用 Runnable 负责定义 run() 办法(执行内容)。这种状况下,它与 Thread 实现理解耦。Thread 负责线程的启动以及相干属性设置。
- 性能
在一些状况下能够进步性能。比方:线程执行的内容很简略,就是打印个日志。如果应用 Thread 实现,那它会从线程创立到销毁都要走一遍,须要屡次执行时,还须要屡次走这反复的流程,内存开销十分大。
然而咱们应用 Runnable 就不一样了。能够把它扔到线程池外面,用固定的线程执行。这样,显然是能够提高效率的。
伟人的肩膀
- Java 并发编程 78 讲 — 徐隆曦
福利
如果看到这里,喜爱这篇文章的话,请帮点个难看。微信搜寻一个优良的废人,关注后回复电子书送你 100+ 本编程电子书 ,不只 Java 哦,详情看下图。回复1024送你一套残缺的 java 视频教程。