写在开头
昨天有个小伙伴私信说自己面试挂在了“Java有几种创建线程的方式”上，我问他怎么回答的，他说自己有背过八股文，回答了：继承Thread类、实现Runnable接口、实现Callable接口、使用线程池这四种，但是面试官让说出8种创建方式，他没说出来，面试就挂了，面试官给的理由是：只关注八股文背诵，对线程的理解不够深刻！
在这里想问一下大家，这位小伙伴回答的这四种有问题吗？看过《Java核心技术卷》和《Java编程思想》的朋友应该都知道，在这两本书中对于多线程编程都有详细的介绍，并且也都提到了线程创建的方式：
- ①继承Thread类，并重写run()方法；
- ②实现Runnable接口，并传递给Thread构造器；
- ③实现Callable接口，创建有返回值的线程；
- ④使用Executor框架创建线程池。
鉴于这两本书的权威性，以及在国内的广泛传播，让很多学习者，写书者，教学者都以此为标准，长此以往，这种回答似乎就成了一种看似完美的标准答案了。
因此，这位小伙伴的回答在大部分面试官那里都是正确的，没有什么大问题，但既然这位面试官抛出了8种的提问，很明显他要的回答并不是八股文参考答案。那应该怎么回答才能征服这位面试官呢？请接着往下看！
创建线程的10种方式
既然面试官想看线程创建的方式，我们就往上整，不仅仅他要的8种，我们还可以说出10种，甚至更多，今天花了点时间，梳理了一下之前用到过得以及网上看到的线程创建的办法，我们通过一个个小demo去感受一下。🥰
① 继承Thread类，并重写run()方法
这是最基本的一个线程创建的方式，闲话少叙，直接上代码！
【代码示例1】public class Test {
public static void main(String[] args) {
new ThreadTest().start();
}
}
//继承 Thread，重写 run() 方法
class ThreadTest extends Thread {
@Override
public void run() {
for (int i = 0; i <3; i++) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
Thread-0:0
Thread-0:1
Thread-0:2
创建一个ThreadTest 并继承Thread类，重写run方法，来创建一个线程，当然我们还可以采用匿名内部类去重写run方法来创建线程，这其实也可以算所一种方式
【代码示例2】public class Test {
public static void main(String[] args) {
new Thread("t1"){
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}.start();
}
}
//打印结果：t1
② 实现Runnable接口
这也是常用的四个方式之一，实现Runnable接口并重写run方法。
【代码示例3】public class Test implements Runnable{
public static void main(String[] args) {
Test test = new Test();
new Thread(test).start();
}
@Override
public void run() {
System.out.println("我是Runnable线程");
}
}
//打印结果：我是Runnable线程
③ 实现Callable接口
这种方式实现Callable接口，可以创建有返回值的线程。
【代码示例4】public class Test implements Callable<String> {
public static void main(String[] args) throws ExecutionException, InterruptedException {
Test test = new Test();
FutureTask<String> stringFutureTask = new FutureTask<>(test);
new Thread(stringFutureTask).start();
System.out.println(stringFutureTask.get());
}
@Override
public String call() throws Exception {
return "我是线程Callable";
}
}
//打印结果：我是线程Callable
这个示例里使用了FutureTask，这个类可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask，直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果。
④ 使用ExecutorService线程池
通过Executors创建线程池，Executors 类是从 JDK 1.5 开始就新增的线程池创建的静态工厂类，它就是创建线程池的，但是很多的大厂已经不建议使用该类去创建线程池。原因在于，该类创建的很多线程池的内部使用了无界任务队列，在并发量很大的情况下会导致 JVM 抛出 OutOfMemoryError，直接让 JVM 崩溃，影响严重。因此，在这里我们只将它作为一个案例参考，真实开发中不建议使用！
【代码示例5】public class Test {
public static void main(String[] args) {
// 使用工具类 Executors 创建单线程线程池,其实还有其他几种创建方式
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
//提交执行任务
singleThreadExecutor.submit(() -> {
System.out.println("单线程线程池执行任务");});
//关闭线程池
singleThreadExecutor.shutdown();
}
}
//打印结果：单线程线程池执行任务
⑤ 使用CompletableFuture类
CompletableFuture是JDK1.8引入的新类，CompletableFuture 除了提供了更为好用和强大的 Future 特性之外，还提供了函数式编程、异步任务编排组合（可以将多个异步任务串联起来，组成一个完整的链式调用）等能力。后面的文章更新中会详说，现在先上代码！
【代码示例6】public class Test {
public static void main(String[] args) throws InterruptedException {
CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread().getName() + ":"+"CompletableFuture");
return "CompletableFuture";
});
// 需要阻塞，否则看不到结果
Thread.sleep(1000);
}
}
//打印结果：ForkJoinPool.commonPool-worker-1:CompletableFuture
⑥ 基于ThreadGroup线程组
在Java的线程中同样有组的概念，可以通过ThreadGroup创建一个线程组，在线程组中创建多个线程。
【代码示例7】public class Test {
public static void main(String[] args) {
ThreadGroup group = new ThreadGroup("groupName");
new Thread(group, ()->{
System.out.println("T1......");
}, "T1").start();
new Thread(group, ()->{
System.out.println("T2......");
}, "T2").start();
new Thread(group, ()->{
System.out.println("T3......");
}, "T3").start();
}
}
T1......
T2......
T3......
⑦ 使用FutureTask类
看到这个FutureTask类是不是很熟悉，对喽！咱们在第三种方式，实现Callable接口，重写call方法中也用到了它，他们的实现方式几乎都万变不离其宗，只不过我们在这里采用了lambda 表达式调用。
【代码示例8】public class Test {
public static void main(String[] args) {
FutureTask<String> futureTask = new FutureTask<>(() -> {
System.out.println(Thread.currentThread().getName()+":"+"futureTask");
return "futureTask";
});
new Thread(futureTask).start();
}
}
//执行结果：Thread-0:futureTask
其实虽然是匿名方式，它的底部仍然调用了callable。我们来看一下FutureTask底层的构造方法，都是通过传参或者调用callable。
【源码解析1】public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
public FutureTask(Runnable runnable, V result) {
// 通过适配器RunnableAdapter来将Runnable对象runnable转换成Callable对象
this.callable = Executors.callable(runnable, result);
this.state = NEW;
}
⑧ 使用匿名内部类或Lambda表达式
这种方式其实在上面的实现中多少都有提到，匿名方式创建，lambda 表达式创建。
【代码示例9】public class Test {
public static void main(String[] args) {
//new Runnable 对象，匿名重写 run() 方法
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名创建线程");
}
}).start();
//JDK 1.8 开始支持 lambda 表达式
new Thread(() ->
System.out.println("lambda创建线程")
).start();
}
}
⑨ 使用Timer定时器类
Timer类在JDK1.3时被引入，用来执行定时任务，里面需要传入两个数字，第一个代表启动后多久开始执行，第二个代表每间隔多久执行一次，单位是ms毫秒。
【代码示例10】public class Test {
public static void main(String[] args) {
Timer timer = new Timer();
timer.schedule(new TimerTask() {
@Override
public void run() {
System.out.println("定时器线程");
}
}, 0, 1000);
}
}
⑩ 使用ForkJoin线程池或Stream并行流
ForkJoin是JDK1.7引入的新线程池，基于分治思想实现。而后续JDK1.8的parallelStream并行流，默认就基于ForkJoin实现，我们直接上代码感受一下。
【代码示例11】public class Test {
public static void main(String[] args) {
//ForkJoinPool线程池
ForkJoinPool forkJoinPool = new ForkJoinPool();
forkJoinPool.execute(()->{
System.out.println(Thread.currentThread().getName()+":"+"ForkJoinPool线程池");
});
//parallelStream流
List<String> list = Arrays.asList(Thread.currentThread().getName()+":"+"parallelStream流");
list.parallelStream().forEach(System.out::println);
}
}
ForkJoinPool-1-worker-1:ForkJoinPool线程池
//并行流在主线程中被打印。
main:parallelStream流
总结
OK，我们根据面试官的需求，写出了10种创建线程的方式，如果再细分，甚至还可以更多，毕竟线程池的工具类还有没往上写的呢。
那么，我们一起静默3分钟，好好思考一下，在Java中创建一个线程的本质，真的是八股文中所说的3种、4种、8种，甚至更多吗？Build哥认为，真正创建线程的方式只有1种，其他的衍生品都算套壳！
考虑到本篇已经六七千字了，所以我们在下一篇文章中来分析一下为什么“真正创建线程的方式只有1种！”
结尾彩蛋
如果本篇博客对您有一定的帮助，大家记得留言+点赞+收藏呀。原创不易，转载请联系Build哥！
