创建线程的方法:
- 继承
Thread
类重写run()
方法。 - 实现
Runnable
接口,重写run()
方法。 - 实现
Callable
接口,重写call()
方法,通过FutureTask
包装器来创建线程。 - 使用线程池创建线程。
其实方法1和方法2经常使用,方法3、4倒是我不怎么用。今天就研究一下方法3、4创建线程的方式。
实现Callable接口创建线程
public class CallableDemo implements Callable<Integer> {
@Override
public Integer call() throws Exception {
Thread.sleep(5000);
return 0;
}
public static void main(String[] args) {
FutureTask<Integer> result=new FutureTask<>(new CallableDemo());
Thread thread=new Thread(result);
thread.start();
System.out.println("start");
try {
System.out.println("result:"+result.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
System.out.println("end");
}
}
这种方式需要借助FutureTask
类来支持。优于方法1、2的一点是可以添加返回值,并且可以抛出异常。
但是需要注意的一点是,如果需要获取返回值result.get()
这个方法是阻塞的。所以你在创建线程和调用result.get()
方法之间没有耗时操作 或者 没有其他线程 效果和顺序执行没有区别,还不如不创建线程。
使用线程池创建线程
public class RunnableDemo implements Runnable{
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
public static void main(String[] args) {
// 创建一个固定大小的线程池:
ExecutorService es = Executors.newFixedThreadPool(4);
for (int i = 0; i < 6; i++) {
es.submit(new RunnableDemo());
}
// 关闭线程池:
es.shutdown();
}
}
- newFixedThreadPool 创建固定大小数量线程池,数量通过传入的参数决定。
- newSingleThreadExecutor 创建一个线程容量的线程池,所有的线程依次执行,相当于创建固定数量为1的线程池。
- newCachedThreadPool 创建可缓存的线程池,没有最大线程限制(实际上是Integer.MAX_VALUE)。如果用空闲线程等待时间超过一分钟,就关闭该线程。
- newScheduledThreadPool 创建计划(延迟)任务线程池,线程池中的线程可以让其在特定的延迟时间之后执行,也可以以固定的时间重复执行(周期性执行)。相当于以前的Timer类的使用。
- newSingleThreadScheduledExecutor 创建单线程池延迟任务,创建一个线程容量的计划任务。
实现Runnable接口创建线程
最常用的还是实现Runnable
接口的方式创建线程。
-
由于Java是单继承,如果继承了
Thread
类就不能继承其他类了。 -
如果线程只是用一次的话也不需要专门写一个类,直接使用匿名内部类的方式。还可以结合jdk8的lambda表达式。
public class RunnableDemo{
public static void main(String[] args) {
new Thread(()->{
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Runnable:"+i);
}
}).start();
}
}
一个经典的线程面试题
如何一个类既继承了Thread类,又实现了Runnable接口。运行start方法的时候是执行重写Thread类里面的run()方法还是执行重写Runnable接口里面的run()方法?如下程序输出什么?
public static void main(String[] args) {
new Thread(()-> System.out.println("Runnable")){
@Override
public void run() {
System.out.println("Thread");
}
}.start();
}
结果输出的是“Thread”。
我们来看一下Thread类的源码。
public class Thread implements Runnable {
private Runnable target;
public Thread(Runnable target) {
init(null, target, "Thread-" + nextThreadNum(), 0);
}
@Override
public void run() {
if (target != null) {
target.run();
}
}
}
我只放了部分方法,init()
方法也不放了,内容就是把传过来的target赋值个this.target
。Thread类的run()
方法里面的逻辑就是target!=null
调用target.run()
。
我们继承了Thread类,重写了run()
方法,当调用start()
方法后,JVM帮我们调用的是重写后的run()
方法,也就执行不到target的run()
方法了。因此输出结果为”Thread“