java创建线程的方式到底有几种？(详解)

多线程系列整体栏目

---

---

一，创建多线程的方式

1，官方解释

在oracle的官方文档中，其官方文档链接如下：https://docs.oracle.com/javase/8/docs/api/index.html

在jdk8中，很明确的表明了创建线程的方式只有两种，重点就是这句 There are two ways to create a new thread of execution. One is to declare a class to be a subclass of Thread . The other way to create a thread is to declare a class that implements the Runnable interface.

翻译过来的意思就是说：有两种方法可以创建一个新的执行线程。一种方法是将一个类声明为Thread的子类。创建线程的另一种方法是声明一个实现Runnable 接口的类

这是权威的官方文档说的，创建线程的方式只有两种，接下来分析一下这两种创建线程的方式的优劣和本质，以及分析一下其他的创建线程方式的底层，如线程池，Future等，看看这些创建线程方式的本质是不是就是官方文档上面的两种方式。

2，实现Runnable接口

其底层就是将实现了Runnable的类作为参数放在创建线程的构造方法中，并且在实现Runnable的类中重写run方法，实现Thread和run方法的解耦

public class RunnableTest implements Runnable{
    public static void main(String[] args) {
        Thread thread = new Thread(new RunnableTest());
        //启动线程
        thread.start();
    }
    //重写run方法
    @Override
    public void run() {
        System.out.println("hello，runnable");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

3，继承Thread类

其底层就是利用继承的方式创建一个线程，然后在继承Thread的类中重写run方法。

public class ThreadTest extends Thread{
    @Override
    public void run() {
        System.out.println("hello，Thread");
    }

    public static void main(String[] args) {
        //启动线程
        new ThreadTest().start();
    }
}
1
2
3
4
5
6
7
8
9
10
11

3，二者区别

3.1，本质区别

无论是使用方式一还是方式二，最终都是通过new Thread的方式来创建线程，但是二者的本质区别就是run方法在何处使用。实现Runnable方式的run方法在实现类中重写run方法，实现了解耦；而继承Thread的方式，如果在出现多继承的情况下，那么中间的类里面的run方法就可能会被覆盖，从而导致run方法中的内容丢失，运行不了。

准确的讲，就是只有一种方式创建线程，就是通过构造Thread类来实现，但是从线程的执行单元来看，执行线程的单元有两种，就是上面所说的根据不同位置重写的run方法来区分。

3.2，优先考虑使用第一种

从解耦的角度来看： 方式一中创建Thread线程和run方法耦合开，方式二耦合在一起，因此方式一优先考虑和选择

从资源的节约上来看： 在每次出现一个任务时，方式二都得手动去创建一个线程，那么线程的创建和销毁都会消耗比较大的资源。而方式一只需要实现runnable接口即可，然后将实现的类作为参数加入到Thread()中，而线程Thread可以通过线程池这样的工具创建和管理，这样就可以减少线程的创建和销毁，这样也是优先考虑和选择方式一。

从继承角度来看： 一个子类只能继承一个父类，那么第二种方式是采用继承的方式，那么只能继承这一种类，这样第二种方式大大的限制了可扩展性，并且多继承的话，可能出现父类的run方法被子类重写，导致父类里面的run方法被覆盖。因此也是优先考虑和选择方式一。

所以终上所述，优先选择方式一。即一般创建线程时，优先使用实现Runnable接口这种方式来创建多线程。

二，误以为是创建线程的几种新方式

1，线程池创建线程的本质

在官方文档中，并没有说线程池是一个可以单独的创建线程的一个方式，但是在日常开发中，我们又是经常通过线程池来创建，管理和监控线程池，那么线程池创建线程的本质到底是什么呢？接下来主要分析一下线程池创建线程的底层源码。

ExecutorService executorService = Executors.newCachedThreadPool();
1

其内部主要是通过一个ThreadPoolExecutor的执行器，而创建线程主要是通过线程工厂创建，因此主要分析这个defaultThreadFactory类

public ThreadPoolExecutor(int corePoolSize,
						  int maximumPoolSize,
	      				  long keepAliveTime,
						  TimeUnit unit,
						  BlockingQueue < Runnable > workQueue) {
	this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
	Executors.defaultThreadFactory(), defaultHandler);
}
1
2
3
4
5
6
7
8

然而在这个线程池创建的线程，如下图，在这个newThead方法中，很清楚的可以知道是需要传一个Runnable的实现到这个参数中，然后通过new Thread(target)的方式来创建线程。

public Thread newThread(Runnable r) {
            Thread t = new Thread(group, r,
                                  namePrefix + threadNumber.getAndIncrement(),
                                  0);
    		return t;
}
1
2
3
4
5
6

即通过线程池的方式创建线程也是使用的是方式一，实现Runaable的接口来完成的，因此使用这个线程池创建线程不能单独作为一种新的创建线程的方式。

2，FutureTask和Callable的本质

2.1，FutureTask和Callable和Thread的结合使用

在这个模式中，先重写call方法，由于在new Thread的构造方法中并没有 Callable 这种类的参数，因此需要借助 FutureTask 这个类来将Callable和这个Thread类就行一个连接。其用法如下

public class FutureTaskTest implements Callable {
    @Override
    public Object call() throws Exception {
        return 4;
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable
        FutureTaskTest th = new FutureTaskTest();
        //创建FutureTask,需要绑定Callable
        FutureTask<Integer> futureTask = new FutureTask<Integer>(th);
        //开启线程
        new Thread(futureTask).start();
        //获取Callable的返回值
        Integer result = futureTask.get();
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

所以说这个FutureTask就是类似于一个中间类，接下来查看一下这个FutureTask这个类的底层，这个类实现了 RunnableFuture 接口，而这个接口继承了这个Runnable这个接口。那么可以说这个FutureTask就是这个Runnable的一个具体的实现了

//实现RunnableFuture接口
class FutureTask<V> implements RunnableFuture<V>{}
//RunnableFuture接口继承了Runnable类
public interface RunnableFuture<V> extends Runnable, Future<V>
1
2
3
4

如图，得知这个RunnableFuture接口继承了Runnable类，并且这是熟知的大名鼎鼎的 Doug Lea，李二狗大师写的。

而这种方式开启线程也是使用 new Thread(target) 的方式实现，而这个target又是Runnable的实现，那么这种方式又是符合方式一，实现Runaable的接口来完成的，因此使用这个Callable创建线程不能单独作为一种新的创建线程的方式。

2.2，FutureTask和Runnable和Thread的结合使用

在这个模式中，显而易见使用的是第一种方式，而FutureTask又是Runnable的一个具体的实现，那么这种方式也符合方式一，即通过实现Runnable接口的方式来完成的，因此这种方式也不能作为一种新的创建线程的方式。

public static class RunnableTest implements Runnable {
    @Override
    public void run() {
        System.out.println("RunnableTest");
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    //创建Runnable对象
    RunnableTest runnable = new RunnableTest();
    Integer result = null;
    //创建FutureTask,需要绑定Runnable
    FutureTask<Integer> futureTask = new FutureTask<Integer>(runnable,result);
    new Thread(futureTask).start();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3，定时器工具类创建线程的本质

在这个 TimerTasks 类中，通过Timer创建一个单线程的任务定时器，然后通过调用 schedule 方法执行这个任务。

public class TimerTasks {
	public static void main(String[] args) {
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {
			public void run() {
				System.out.println("=============定时任务已经开启========" + System.currentTimeMillis());
			}
		}, 0, 1000);
	}
}
1
2
3
4
5
6
7
8
9
10

接下来主要看这个 schedule 方法，如下图。

重点查看里面的 sched 方法里面的第一个参数，是一个 TimerTask 的抽象类，并且进入这个抽象类的源码又可以发现，这个类实现了 Runnable 接口，那么这种方式也符合方式一，即通过实现Runnable接口的方式来完成的，因此这种方式也不能作为一种新的创建线程的方式。

public abstract class TimerTask implements Runnable {...}
1

三，总结

通过上面几种创建线程的方式举例，那么这个创建线程到底有几种方式的答案相信已经呼之欲出了，没错就是一开始所说的两种：一种是通过实现Runnable接口，另一种就是继承Thread类。并且从本质上来说，只有一种，就是通过创建 Thread 类实现，而上面的两种也是通过run方法在不同的位置的实现来区分的。而下面的几种创建线程的方式虽然用的多，但是究其本质，其底层源码还是脱离不了这两种创建线程的方式的。