Java并发编程—实现线程的方式的四种方式

这是我2021年的第1篇原创文章，原汁原味的技术之路尽在Jerrycodes

---

    多线程操作一直是后端技术的重中之重，对于一个Java开发人员来说，熟悉多线程并发是基本操作。在生产环境中，常常会有秒杀活动的出现，多线程竞争必不可少。

    面试的时候经常会问到多线程的问题，实战中经常有多线程争夺资源的情况...最近很火的秒杀茅台，本质就是多个线程去抢占一个茅台，只不过有的人用的是手工抢夺方式，有的人用的是脚本抢夺方式。当然我手中只有一瓶茅台，自然不能卖出去十几瓶茅台，这就关乎了多线程安全的问题了。

    接下来我们来看看实现线程的几种方式，以及他们之间的区别。先给出一个结论，线程的实现方式实际上从根本上只有一种。

实现 Runnable 接口

class MyThread implements Runnable {   // 定义线程主体类
    private String name;       // 定义类中的属性
    public MyThread(String name) {    // 定义构造方法
      this.name = name;
    }
    @Override
    public void run() {        // 覆写run()方法
        for (int x = 0; x < 200; x++) {
          System.out.println(this.name + " --> " + x);
      }
    }
}

首先通过 MyThread 类实现 Runnable 接口，然后重写 run() 方法，之后只需要把这个实现了 run() 方法的 MyThread 实例传到 Thread 类中就可以实现多线程。

如何运行Runnable线程：

MyThread a = new MyThread();
new Thread(a).start();

继承 Thread 类

class MyThread extends Thread {   // 这就是一个多线程的操作类
    private String name ;     // 定义类中的属性
    public MyThread(String name) {  // 定义构造方法
      this.name = name ;
   }
   @Override
   public void run() {      // 覆写run()方法，作为线程的主操作方法
      for (int x = 0 ; x < 200 ; x ++) {
         System.out.println(this.name + " --> " + x);
      }
   }
}

与第 1 种方式不同的是它没有实现接口，而是继承 Thread 类，并重写了其中的 run() 方法。相信上面这两种方式你一定非常熟悉，并且经常在工作中使用它们。

由Thread类的定义可知Thread类也是Runnable接口的子类：

public class Thread extends implements Runnable

因而启动一个Thread类线程有两种方式：

new MyThread().start();

MyThread a = new MyThread();
new Thread(a).start();

有返回值的 Callable 创建线程

先说一下java.lang.Runnable吧，它是一个接口，在它里面只声明了一个run()方法：

public interface Runnable {
    public abstract void run();
}

无论是使用Thread还是Runnable都无法返回值，这一点是它们的共同缺点。JDK1.5之后提出了Callable。

1. Callable接口更像是Runnable接口的增强版，相比较Runable接口,Call()方法新增捕获和抛出异常的功能;Call()方法可以返回值

2. Future接口提供了一个实现类FutureTask实现类，FutureTaks类用来保存Call()方法的返回值，并作为Thread类的target。

3. 调用FutureTask的get()方法来获取返回值

class CallableTask implements Callable<Integer> {

    @Override

    public Integer call() throws Exception {

        return new Random().nextInt();

    }

}

但是在Thread类中并没有接受Callable实例对象的方式，在实现Callable之后需要借助FutureTask类，在JDK1.5之后Java提供了java.util.concurrent.FutureTask。

来看看FutureTask的两种构造方法：

public FutureTask(Callable<V> callable)

public FutureTask(Runnable runnable,V result)

其基本的类继承结构如图所示，可以发现FutureTask实现了RunnableFuture接口，而RunnableFuture又实现了Future和Runnable接口

所以无论是 Callable 还是 FutureTask，它们首先和 Runnable 一样，都是一个任务，是需要被执行的，而不是说它们本身就是线程。它们可以放到线程池中执行，不管用什么方法，最终都是靠线程来执行的，而子线程的创建方式仍脱离不了最开始讲的两种基本方式，也就是实现 Runnable 接口和继承 Thread 类。

//创建线程池
ExecutorService service = Executors.newFixedThreadPool(10);
//提交任务，并用 Future提交返回结果
Future<Integer> future = service.submit(new CallableTask());

线程池创建线程

线程池确实实现了多线程，比如我们给线程池的线程数量设置成 10，那么就会有 10 个子线程来为我们工作，接下来，我们深入解析线程池中的源码，来看看线程池是怎么实现线程的？

static class DefaultThreadFactory implements ThreadFactory {

    DefaultThreadFactory() {

        SecurityManager s = System.getSecurityManager();

        group = (s != null) ? s.getThreadGroup() :

            Thread.currentThread().getThreadGroup();

        namePrefix = "pool-" +

            poolNumber.getAndIncrement() +

            "-thread-";
    }


    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()创建线程的 ，只不过这里的构造函数传入的参数要多一些，由此可以看出通过线程池创建线程并没有脱离最开始的那两种基本的创建方式，因为本质上还是通过 new Thread() 实现的。

所以我们在回答线程实现的问题时，描述完前两种方式，可以进一步引申说“我还知道线程池和Callable 也是可以创建线程的，但是它们本质上也是通过前两种基本方式实现的线程创建。”这样的回答会成为面试中的加分项。

总结1：实现线程只有一种方式

关于这个问题，我们先不聚焦为什么说创建线程只有一种方式，先认为有两种创建线程的方式，而其他的创建方式，比如线程池或是定时器，它们仅仅是在 new Thread() 外做了一层封装，如果我们把这些都叫作一种新的方式，那么创建线程的方式便会千变万化、层出不穷，比如 JDK 更新了，它可能会多出几个类，会把 new Thread() 重新封装，表面上看又会是一种新的实现线程的方式，透过现象看本质，打开封装后，会发现它们最终都是基于 Runnable 接口或继承 Thread 类实现的。

总结2：实现 Runnable 接口比继承 Thread 类实现线程要好

下面我们来对刚才说的两种实现线程内容的方式进行对比，也就是为什么说实现 Runnable 接口比继承 Thread 类实现线程要好？好在哪里呢？

1. 实现 Runnable 与 Thread 类的解耦。Runnable 里只有一个 run() 方法，它定义了需要执行的内容，在这种情况下，Thread 类负责线程启动和属性设置等内容，权责分明。

2. 提高性能。使用继承 Thread 类方式，每次执行一次任务，都需要新建一个独立的线程，如果还想执行这个任务，就必须再新建一个继承了 Thread 类的类，整个线程从开始创建到执行完毕被销毁，这一系列的操作比 run() 方法打印文字本身带来的开销要大得多，相当于捡了芝麻丢了西瓜，得不偿失。如果我们使用实现 Runnable 接口的方式，就可以把任务直接传入线程池，使用一些固定的线程来完成任务，不需要每次新建销毁线程，大大降低了性能开销。

3. Java 语言不支持双继承，如果我们的类一旦继承了 Thread 类，那么它后续就没有办法再继承其他的类，这样一来，如果未来这个类需要继承其他类实现一些功能上的拓展，它就没有办法做到了，相当于限制了代码未来的可拓展性。

综上所述，我们应该优先选择通过实现 Runnable 接口的方式来创建线程。

总结3：为什么多线程启动不是调用run()而是start()

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
     // 没有初始化，抛出异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
 
    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);
 // 是否启动的标识符
    boolean started = false;
    try {
     // start0() 是启动多线程的关键
     // 这里会创建一个新的线程，是一个 native 方法
     // 执行完成之后，新的线程已经在运行了
        start0();
        // 主线程执行
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

start 方法的源码也没几行代码，注释也比较详细，最主要的是 start0() 方法，这个后面在解释。再来看看 run() 方法的源码：

    @Override
    public void run() {
     // 简单的运行，不会新起线程，target 是 Runnable
        if (target != null) {
            target.run();
        }
    }

run() 方法的源码就比较简单的，就是一个普通方法的调用，这也印证了我们上面的结论。

接下来我们就来说一说这个 start0() 这个方法，这个是真正实现多线程的关键，start0() 代码如下：

private native void start0();

start0 被标记成 native ，也就是本地方法，并不需要我们去实现或者了解。

start() 方法调用 start0() 方法后，该线程并不一定会立马执行，只是将线程变成了可运行状态。具体什么时候执行，取决于 CPU ，由 CPU 统一调度。

我们又知道 Java 是跨平台的，可以在不同系统上运行，每个系统的 CPU 调度算法不一样，所以就需要做不同的处理，这件事情就只能交给 JVM 来实现了，start0() 方法自然就表标记成了 native。

Java 中实现真正的多线程是 start 中的 start0() 方法，run() 方法只是一个普通的方法。

码到这里，何不来个在看？