多线程 | Thread 和 Runnable 执行流程的差异-技术圈

早期文章

大数据 | Java 操作 HDFS 常用 API
大数据 | HDFS 常用操作命令
Redis | Redis 也会算距离
Spring Cloud Gateway 的简单搭建
服务注册、发现和远程调用
让 MongoDB 的 CRUD 有 JPA 的味道
使用 MongoTemplate 对 MongoDB 进行 CRUD
省内存的 Excel 导入导出库还是得了解下它...
后端程序员的 VUE 超简单入门笔记
后端程序员的 ES6 超简单入门笔记
看完即可上手 MyBatis-Plus
奇怪的函数调用
打造后台登录页面扫描工具
一道有趣的 Java 基础题
Spring 拦截器流程及多个拦截器的顺序
Docker常用命令
Docker 使用 MySQL
JWT库生成Token的使用与原理
Java 项目中几个必不可少的小功能

上图来自网络

一、查看源码

在 Java 中创建自定义线程通常有两种方法，一种方法是继承 Thread 类，另外一种方法是实现 Runnable 接口。

无论是使用继承 Thread 类的方式，还是实现 Runnable 接口的方式，本质上是没有差别的。因为 Thread 本身也是实现了 Runnable 接口的。查看 Thread 类的定义，定义如下：

class Thread implements Runnable

如果使用继承 Thread 类的方式，通常，我们会定义一个 MyThread 类来继承 Thread 类，并重写 run 方法，然后 new 一个 MyThread 实例，通过这个实例调用 start 方法，让 JVM 来启动这个线程。

如果使用实现 Runnable 接口的方式，通常，我们也会定义一个 MyRunnable 类来实现 Runnable 接口，并重写 run 方法，然后 new 一个 MyRunnable 实例，但是 MyRunnable 实例是并没有 start 方法的。因此，仍然需要 new 一个 Thread 类的实例，将 MyRunnable 实例当作参数传递给 Thread 的构造方法，最后同样通过 Thread 实例的 start 方法，让 JVM 来启动线程。

这里来看一下，Thread 类的构造方法，Thread 类的构造方法有若干个，现在主要来看它的无参构造方法和传递 Runnable 类型的构造方法，代码如下：

public Thread() {    init(null, null, "Thread-" + nextThreadNum(), 0);}
public Thread(Runnable target) {    init(null, target, "Thread-" + nextThreadNum(), 0);}

两个构造函数，都调用了 init 方法。传递 Runnable 类型参数的构造方法比无参构造方法多了一个 target 传递给 init 方法。来看 init 方法的代码：

private void init(ThreadGroup g, Runnable target, String name,                  long stackSize, AccessControlContext acc,                  boolean inheritThreadLocals) {    // ...        this.target = target;        // ...}

对于 target 参数给出的注释为：

the object whose run() method gets called

表示调用 run() 方法的对象，接着来看一下 Thread 类中的 run 方法，代码如下：

@Overridepublic void run() {    if (target != null) {        target.run();    }}

代码里会判断 target 是否不为 null，不为 null 则调用 target.run。再来看该方法的注释：

If this thread was constructed using a separate Runnable run object, then that Runnable object's run method is called; otherwise, this method does nothing and returns.Subclasses of Thread should override this method.

如果此线程是使用单独的 Runnable run 对象构造的，则调用该 Runnable 对象的 run方法；否则，此方法不执行任何操作并返回。接下来通过实例来调试分析一下。

二、实例分析

先来写一个继承 Thread 的类的方式来进行观察，代码如下：

public class MyThread extends Thread {
    @Override    public void run() {        System.out.println(Thread.currentThread().getName());    }
    public static void main(String[] args) {        Thread myThread = new MyThread();
        myThread.start();
        System.out.println(Thread.currentThread().getName());    }}

此时，分别在 Thread 类的 run 方法下断，在 MyThread 的 run 方法下断，然后调试运行，代码直接中断在了 MyThread 类的 run 方法处。调试运行代码发现，并没有中断在 Thread 类的 run 方法处，按照面向对象的设计来说，子类方法覆盖了父类的方法，当前对象是子类的实例，则应该直接调用子类的方法。

再来写一个实现 Runnable 的代码，代码如下：

public class MyRunnable implements Runnable {    @Override    public void run() {        System.out.println(Thread.currentThread().getName());    }

    public static void main(String[] args) {        Runnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);        thread.start();
        System.out.println(Thread.currentThread().getName());    }}

同样的操作，在 Thread 类的 run 方法和 MyRunnable 的 run 方法处分别设置断点，然后调试运行，代码首先中断在了 Thread 类的 run 方法，然后继续运行，代码又中断在了 MyRunnable 的 run 方法。此时观察调用栈会看到 MyRunnable 的 run 方法是 Thread 类的 run 方法调用的。

三、总结

通过查看源码以及实例代码调试发现，实现 Runnable 接口在代码执行的流程上比继承 Thread 类的流程要稍微复杂些。不过实现 Runnable 接口的方法应该更符合软件的设计原则。当然了，在项目中不建议显式的创建线程，更推荐的是使用线程池。