实现多线程的方法是 1 种还是 2 种还是 4 种?
预计阅读 5 分钟

实现多线程的方法是 1 种还是 2 种还是 4 种?

技术发布于 2026年6月3日

实现多线程的方法是 1 种还是 2 种还是 4 种?

网上的说法

正确的说法

  • 实现多线程的官方正确方法: 2 种。

  • Oracle 官网的文档说明

  • 方法小结

  • 方法一: 实现 Runnable 接口。

  • 方法二: 继承 Thread 类。

  • 代码示例

Java
1package cn.xilikeli.threadcoreknowledge.createthreads;
2
3/**
4 * <p>
5 * 实现 Runnable 接口的方式创建线程
6 * </p>
7 *
8 * @author 踏雪彡寻梅
9 * @version 1.0
10 * @date 2020/9/7 - 00:34
11 * @since JDK1.8
12 */
13public class RunnableStyle implements Runnable {
14    @Override
15    public void run() {
16        System.out.println("用 Runnable 方式实现线程~~~");
17    }
18
19    public static void main(String[] args) {
20        Thread thread = new Thread(new RunnableStyle());
21        thread.start();
22    }
23}
Java
1package cn.xilikeli.threadcoreknowledge.createthreads;
2
3/**
4 * <p>
5 * 继承 Thread 类的方式创建线程
6 * </p>
7 *
8 * @author 踏雪彡寻梅
9 * @version 1.0
10 * @date 2020/9/7 - 00:37
11 * @since JDK1.8
12 */
13public class ThreadStyle extends Thread {
14    @Override
15    public void run() {
16        System.out.println("用 Thread 方式实现线程~~~");
17    }
18
19    public static void main(String[] args) {
20        new ThreadStyle().start();
21    }
22}
  • 两种方式的对比
  • 方法一（实现 Runnable 接口）更好。
  • 方法二的缺点:
    1. 从代码的架构去考虑，具体执行的任务也就是 run 方法中的内容，它应该和线程的创建、运行的机制也就是 Thread 类是解耦的。所以不应该把他们混为一谈。从解耦的角度，方法一更好。
    2. 该方法每次如果想新建一个任务，只能去新建一个独立的线程，而新建一个独立的线程这样的损耗是比较大的，它需要去创建、然后执行，执行完了还要销毁；而如果使用 Runnable 接口的方式，我们就可以利用线程池之类的工具，利用这些工具就可以大大减小这些创建线程、销毁线程所带来的损耗。所以方法一相比于方法二的这一点，好在资源的节约上。
    3. 继承了 Thread 类之后，由于 Java 不支持双继承，那么这个类就无法继承其他的类了，这大大限制了我们的可扩展性。
  • 两种方式的本质区别
  • 方法一: 最终调用 target.run; ，通过以下两图可以知道使用这个方法时实际上是传递了一个 target 对象，执行了这个对象的 run 方法。

  • 方法二: run() 整个都被重写。一旦子类重写了父类的方法，原有方法会被覆盖被抛弃，即以下代码不会被这次调用所采纳。

  • 综上，两种方法都是执行了 run 方法，只不过 run 方法的来源不同。

  • 思考: 同时使用两种方法会怎样?

  • 代码

Java
1package cn.xilikeli.threadcoreknowledge.createthreads;
2
3/**
4 * <p>
5 * 同时使用 Runnable 和 Thread 两种实现线程的方式
6 * </p>
7 *
8 * @author 踏雪彡寻梅
9 * @version 1.0
10 * @date 2020/9/7 - 22:38
11 * @since JDK1.8
12 */
13@SuppressWarnings("all")
14public class BothRunnableThread {
15    public static void main(String[] args) {
16        new Thread(new Runnable() {
17            @Override
18            public void run() {
19                System.out.println("我来自 Runnable。。。");
20            }
21        }) {
22            @Override
23            public void run() {
24                System.out.println("我来自 Thread。。。");
25            }
26        }.start();
27    }
28}

  • 运行结果

  • 分析

  • 从面向对象的思想去考虑

    1. 首先创建了一个匿名内部类 Thread。传入了一个 Runnable 对象。
    2. 然后重写了 Thread 的 run 方法。最后启动线程。
    3. 因为重写了 Thread 的 run 方法，所以它父类的 run 方法就被覆盖掉了，所以即便传入了 Runnable 对象也不会执行它。

  • 总结

  • 准确的讲，创建线程只有一种方式那就是构造 Thread 类，而实现线程的执行单元有两种方式（run 方法的两种不同实现情况）。

    • 方法一: 实现 Runnable 接口的 run 方法，并把 Runnable 实例传给 Thread 类，再让 Thread 类去执行这个 run 方法。
    • 方法二: 重写 Thread 的 run 方法（继承 Thread 类）。

经典错误观点

  1. ”线程池创建线程也算是一种新建线程的方式。“
    • 线程池创建线程代码示例
    Java
    1package cn.xilikeli.threadcoreknowledge.createthreads.wrongways;
2
3import java.util.concurrent.ExecutorService;
4import java.util.concurrent.Executors;
5
6/**
7 * <p>
8 * 线程池创建线程的方法
9 * </p>
10 *
11 * @author 踏雪彡寻梅
12 * @version 1.0
13 * @date 2020/9/7 - 23:05
14 * @since JDK1.8
15 */
16public class ThreadPools {
17     public static void main(String[] args) {
18        ExecutorService executorService = Executors.newCachedThreadPool();
19        for (int i = 0; i < 1000; i++) {
20            // 添加任务
21            executorService.submit(new Task() {});
22        }
23    }
24}
25
26class Task implements Runnable {
27    @Override
28    public void run() {
29        try {
30            Thread.sleep(500);
31        } catch (Exception e) {
32            e.printStackTrace();
33        }
34        System.out.println(Thread.currentThread().getName());
35    }
36}

    • 线程池创建线程源码

    • 分析

    • 通过线程池中的源码，可以知道线程池创建线程的方式也是通过构造 Thread 的方式创建的。所以线程池创建线程的本质和上文中是一样的。所以不能简单的认为线程池也是一种新的创建线程的方式。

  2. ”通过 Callable 和 FutureTask 创建线程，也算是一种新建线程的方式。“
    • 类图展示

    • 分析
    • 从类图中可以知道这两个创建线程的本质也是和之前的一样的。
  3. ”无返回值是实现 Runnable 接口，有返回值是实现 Callable 接口，所以 Callable 是新的实现线程的方式。“
    • 和第 2 点差不多。
  4. 定时器是新的实现线程的方式。
    • 定时器实现线程代码示例
    Java
    1package cn.xilikeli.threadcoreknowledge.createthreads.wrongways;
2
3import java.util.Timer;
4import java.util.TimerTask;
5
6/**
7 * <p>
8 * 定时器创建线程
9 * </p>
10 *
11 * @author 踏雪彡寻梅
12 * @version 1.0
13 * @date 2020/9/7 - 23:48
14 * @since JDK1.8
15 */
16public class DemoTimmerTask {
17    public static void main(String[] args) {
18        Timer timer = new Timer();
19        timer.scheduleAtFixedRate(new TimerTask() {
20            @Override
21            public void run() {
22                System.out.println(Thread.currentThread().getName());
23            }
24        }, 1000, 1000);
25    }
26}
    • 分析
    • 和前面几点一样，定时器创建线程的方法最终本质也离不开上文中的那两类方法。
  5. 匿名内部类和 Lambda 表达式的方式创建线程是新的创建线程方式。
    • 实际上也和前面几点一样是一个表面现象，本质上还是那两种方法。
    • 代码示例
    Java
    1package cn.xilikeli.threadcoreknowledge.createthreads.wrongways;
2
3/**
4 * <p>
5 * 匿名内部类创建线程
6 * </p>
7 *
8 * @author 踏雪彡寻梅
9 * @version 1.0
10 * @date 2020/9/7 - 23:54
11 * @since JDK1.8
12 */
13public class AnonymousInnerClassDemo {
14    public static void main(String[] args) {
15        // 第一种
16        new Thread() {
17            @Override
18            public void run() {
19                System.out.println(Thread.currentThread().getName());
20            }
21        }.start();
22
23        // 第二种
24        new Thread(new Runnable() {
25            @Override
26            public void run() {
27                System.out.println(Thread.currentThread().getName());
28            }
29        }).start();
30    }
31}
32
33
34
35package cn.xilikeli.threadcoreknowledge.createthreads.wrongways;
36
37/**
38 * <p>
39 * Lambda 表达式创建线程
40 * </p>
41 *
42 * @author 踏雪彡寻梅
43 * @version 1.0
44 * @date 2020/9/7 - 23:58
45 * @since JDK1.8
46 */
47public class LambdaDemo {
48    public static void main(String[] args) {
49        new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
50    }
51}
    • 运行结果

    • 总结
    • 多线程的实现方式，在代码中写法千变万化，但其本质万变不离其宗。

常见面试问题

  • 有多少种实现线程的方法?思路有 5 点。
  • 从不同的角度看，会有不同的答案。
  • 典型答案是两种。这两种方式的对比。
  • 我们看原理，两种本质都是一样的（都是实现 run 方法）。
  • 具体展开说其他方式（代码的实现上的不同方式，原理还是基于那两个本质）。
  • 将以上几点做结论。
  • 实现 Runnable 接口和继承 Thread 类哪种方式更好?
  • 从代码架构角度。（应该去解耦，两件事情：1.具体的任务即 run 方法中的内容；2.和线程生命周期相关的如创建线程、运行线程、销毁线程即 Thread 类去做的事情）
  • 新建线程的损耗的角度。（继承 Thread 类，需要新建线程、执行完之后还要销毁，实现 Runnable 接口的方式可以反复的利用同一个线程，比如线程池就是这么做的，用于线程生命周期的损耗就减少了）
  • Java 不支持多继承的角度。（对于扩展性而言）

继续阅读

推荐阅读

技术2026年6月3日Java8新特性抽象类回顾 jdk1.8 之前，接口里只能做方法定义不能有方法的实现，因此通常会在抽象类里面实现默认的方法，一般这个默认的方法是抽象后公用的方法，不需要每一个继承者都去实现，只需调用即可，就像下面这样： java // 定义 public abstract class AFormula { abstract double calculate int a ; // 平方根 double sqrt i技术2026年6月3日线程 8 大核心基础线程 8 大核心基础技术2026年6月3日并发编程的基石-多线程概念建立并发编程的基石 多线程概念建立 什么是线程、进程? 操作系统、进程、线程的包含关系 操作系统是包含多个进程的容器，而每个进程又都是容纳多个线程的容器。 Oracle 文档的官方定义 进程： 使用fork（2）系统调用创建的UNIX环境（例如文件描述符，用户ID等），它被设置为运行程序。 线程：在进程上下文中执行的一系列指令。 什么是进程? 进程的英文是Process，指的是程序的一次执行，在用户下
实现多线程的方法是 1 种还是 2 种还是 4 种? | 博击长空