多线程有几种实现方式？如果被问到这个问题一定很头疼，因为百度一下随便就能出现各种各样的答案。两种、三种、四种、五种、六种、七种。。。
但本质上来讲，个人认为只有一种方式：实现Runnable接口。
先放个图：
1、实现Runnable接口
1 public class DemoThreadTask implements Runnable{
2 @Override
3 public void run() {
4 // TODO Auto-generated method stub
5 }
6
7 public static void main(String[] args) {
8 DemoThreadTask task = new DemoThreadTask();
9 Thread t = new Thread(task);
10 t.start();
11 ...
12 }
13 }
实现Runnable接口，利用Runnable实例构造Thread，是较常用且最本质实现。
此构造方法相当于对Runnable实例进行一层包装，在线程t启动时，调用Thread的run方法从而间接调用target.run()：
1 public class Thread implements Runnable {
2 /* What will be run. */
3 private Runnable target;
4
5 public void run() {
6 if (target != null) {
7 target.run();
8 }
9 }
10 ...
11 }
2、继承Thread类
1 public class DemoThread extends Thread{
2 @Override
3 //重写run方法
4 public void run() {
5 // TODO Auto-generated method stub
6 }
7
8 public static void main(String[] args) {
9 DemoThread t = new DemoThread();
10 t.start();
11 ...
12 }
13 }
这种实现方式是显示的继承了Thread，但从类图中我们可以看到，Thread类本身就继承自Runnable，所以继承Thread的本质依然是实现Runnable接口定义的run方法。
需要注意的是继承Thread方式，target对象为null，重写了run方法，导致方式1中的Thread原生的run方法失效，因此并不会调用到target.run()的逻辑，而是直接调用子类重写的run方法。
因为java是单根继承，此方式一般不常用。
3、实现Callable接口并通过FutureTask包装
1 public class DemoCallable implements Callable<String>{
2 @Override
3 public String call() throws Exception {
4 // TODO Auto-generated method stub
5 return null;
6 }
7
8 public static void main(String[] args) throws Exception {
9 DemoCallable c = new DemoCallable();
10 FutureTask<String> future = new FutureTask<>(c);
11 Thread t = new Thread(future);
12 t.start();
13 ...
14 String result = future.get(); //同步获取返回结果
15 System.out.println(result);
16 }
17 }
实现Callable接口通过FutureTask包装，可以获取到线程的处理结果，future.get()方法获取返回值，如果线程还没执行完，则会阻塞。
这个方法里，明明没有看到run方法，没有看到Runnable，为什么说本质也是实现Runnable接口呢？
回看开篇的类图，FutureTask实现了RunnableFuture，RunnableFuture则实现了Runnable和Future两个接口。
因此构造Thread时，FutureTask还是被转型为Runnable使用。因此其本质还是实现Runnable接口。
至于FutureTask的工作原理，后续篇章继续分析。
4、匿名内部类
匿名内部类也有多种变体，上述三种方式都可以使用匿名内部类来隐式实例化。
1 public class Demo{
2
3 public static void main(String[] args) throws Exception {
4 //方式一：Thread匿名内部类
5 new Thread(){
6 @Override
7 public void run() {
8 // TODO Auto-generated method stub
9 }
10 }.start();
11
12 //方式二：Runnable匿名内部类
13 new Thread(new Runnable() {
14 @Override
15 public void run() {
16 // TODO Auto-generated method stub
17 }
18 }).start();
19
20 ...
21 }
22 }
匿名内部类的优点在于使用方便，不用额外定义类，缺点就是代码可读性差。
5、Lambda表达式
Lambda表达式是jdk8引入的，已不是什么新东西，现在都jdk10了。demo如下：
1 public class Demo{
2 public static void main(String[] args) throws Exception {
3 new Thread(() -> System.out.println("running") ).start() ;
4 ...
5 }
6 }
如此简洁的Lambda表达式，有没有吸引到你呢？当然本质不多说，还是基于Runnable接口。
6、线程池
1 public class DemoThreadTask implements Runnable{
2 @Override
3 public void run() {
4 // TODO Auto-generated method stub
5 System.out.println("running");
6 }
7
8 public static void main(String[] args) {
9 DemoThreadTask task = new DemoThreadTask();
10 ExecutorService ex = Executors.newCachedThreadPool();
11 ex.execute(task);
12 ...
13 }
14 }
线程池与前面所述其他方式的区别在于执行线程的时候由ExecutorService去执行，最终还是利用Thread创建线程。
线程池的优势在于线程的复用，从而提高效率。
7、定时器
1 public class DemoTimmerTask {
2
3 public static void main(String[] args) throws Exception {
4 Timer timer = new Timer();
5 timer.scheduleAtFixedRate((new TimerTask() {
6 @Override
7 public void run() {
8 System.out.println("定时任务1执行了....");
9 }
10 }), 2000, 1000);
11 }
12 }
TimerTask的实现了Runnable接口，Timer内部有个TimerThread继承自Thread，因此绕回来还是Thread + Runnable。
总结，多线程的实现方式，在代码中写法千变万化，但其本质万变不离其宗。
本质都是实现 Runnable 。
参考：
https://www.jianshu.com/p/7950ea349dbb