Java 中有几种创建线程的方式?

• 1. Java 程序天然就是多线程的
• 2. 线程的启动与终止
• • 2.1 线程的启动
  • • （1）继承 Thread 类，重写 run() 方法
    • （2）实现 Runnable 接口，重写 run() 方法
    • （3）Thread 和 Runnable 的区别
    • （4）Callable、Future 和 FutureTask
  • 2.2 中止线程
  • • （1）线程自然终止
    • （2）stop
    • （3）中断
  • 2.3 深入理解 run() 和 start()
• 3. Java 中有几种方式创建一个线程？

1. Java 程序天然就是多线程的

一个 Java 程序从 main() 方法开始执行，然后按照既定的代码逻辑执行，看似没有其他线程参与，但实际上 Java 程序天生就是多线程程序，因为执行 main() 方法的是一个名称为 main 的线程。

public static void main(String[] args) {
    // Java 虚拟机线程系统的管理接口
    ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
    // 不需要获取同步的 monitor 和 synchronizer 信息，仅仅获取线程和线程堆栈信息
    ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);
    // 遍历线程
    for (ThreadInfo threadInfo : threadInfos) {
        System.out.println("线程ID：" + threadInfo.getThreadId() + "，线程名：" + threadInfo.getThreadName());
    }
}

而一个 Java 程序的运行就算是没有用户自己开启的线程，实际也有有很多 JVM 自行启动的线程，一般来说有：

/Library/Java/JavaVirtualMachines/jdk1.8.0_301.jdk/Contents/Home/bin/java ...
线程ID：5，线程名：Monitor Ctrl-Break
线程ID：4，线程名：Signal Dispatcher
线程ID：3，线程名：Finalizer
线程ID：2，线程名：Reference Handler
线程ID：1，线程名：main

Process finished with exit code 0

1. main - main 线程，用户程序入口；
2. Reference Handler - 清除 Reference 的线程；
3. Finalizer - 调用对象 finalize 方法的线程；
4. Signal Dispatcher - 分发处理发送给 JVM 信号的线程；
5. Monitor Ctrl-Break - 监控 Ctrl-Break 中断信号。

不同的 JDK 版本，启动的线程数会有差异，但这依然证明了 Java 程序天生就是多线程的。

2. 线程的启动与终止

2.1 线程的启动

（1）继承 Thread 类，重写 run() 方法

/**
 * @author pointer
 * @date 2023-03-26 14:57:49
 */
public class NewThread {

    static class MyThread extends Thread {
        @Override
        public void run() {
            // do something
            System.out.println("继承 Thread 类，重写 run() 方法创建线程");
        }
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start();
    }
}

（2）实现 Runnable 接口，重写 run() 方法

/**
 * @author pointer
 * @date 2023-03-26 14:57:49
 */
public class NewThread {

    static class MyRunnable implements Runnable {
        @Override
        public void run() {
            // do something
            System.out.println("实现 Runnable 接口，重写 run() 方法");
        }
    }

    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start();
    }
}

（3）Thread 和 Runnable 的区别

Thread 才是 Java 里对线程的唯一抽象，Runnable 只是对任务（业务逻辑）的抽象。Thread 可以接受任意一个 Runnable 的实例并执行。

Runnable 是一个接口，在它里面只声明了一个 run()方法，由于 run( )方法返回值为 void 类型，所以在执行完任务之后无法返回任何结果。

（4）Callable、Future 和 FutureTask

Callable 位于 java.util.concurrent 包下，它也是一个接口，与 Runnable 接口类似，因为两者都是为其实例可能由另一个线程执行的类设计的。然而，Runnable 不返回结果，也不能抛出异常。

Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get() 方法获取执行结果，该方法会阻塞直到任务返回结果。

因为 Future 只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的 FutureTask：

FutureTask 类实现了 RunnableFuture 接口，RunnableFuture 继承了 Runnable 接口和 Future 接口，而 FutureTask 实现了 RunnableFuture 接口。所以它既可以作为 Runnable 被线程执行，又可以作为 Future 得到 Callable 的返回值。

因此我们通过一个线程运行 Callable，但是 Thread 不支持构造方法中传递 Callable 的实例，所以我们需要通过 FutureTask 把一个 Callable 包装成 Runnable，然后再通过这个 FutureTask 拿到 Callable 运行后的返回值。

/**
 * @author pointer
 * @date 2023-03-26 14:57:49
 */
public class NewThread {

    static class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            int sum = 0;
            for (int i = 0; i < 101; i++) {
                sum += i;
            }
            return sum;
        }
    }

    public static void main(String[] args) {
        MyCallable myCallable = new MyCallable();
        // 1. 用 FutureTask 接收结果
        FutureTask<Integer> futureTask = new FutureTask<>(myCallable);
        new Thread(futureTask).start();

        // 2. 接收线程运算后的结果
        // futureTask.get() - 这个是堵塞性的等待
        try {
            Integer sum = futureTask.get();
            System.out.println("sum = " + sum);
            System.out.println("-------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

2.2 中止线程

（1）线程自然终止

要么是 run() 执行完成了，要么是抛出了一个未处理的异常导致线程提前结束。

（2）stop

暂停、恢复和停止操作对应在线程 Thread 的 API 就是 suspend()、resume() 和 stop()。但是这些 API 是过期的，也就是不建议使用的。

不建议使用的原因主要有：

以 suspend() 方法为例：在调用后，线程不会释放已经占有的资源（比如锁），而是占有着资源进入睡眠状态，这样容易引发死锁问题。同样，stop() 方法在终结一个线程时不会保证线程的资源正常释放，通常是没有给予线程完成资源释放工作的机会，因此会导致程序可能工作在不确定状态下。正因为 suspend()、resume() 和 stop() 方法带来的副作用，这些方法才被标注为不建议使用的过期方法。

（3）中断

安全的中止则是其他线程通过调用某个线程 A 的 interrupt() 方法对其进行中断操作, 中断好比其他线程对该线程打了个招呼，“A，你要中断了”，不代表线程 A 会立即停止自己的工作，同样的 A 线程完全可以不理会这种中断请求。

线程通过检查自身的中断标志位是否被置为 true 来进行响应，线程通过方法 isInterrupted() 来进行判断是否被中断，也可以调用静态方法 Thread.interrupted() 来进行判断当前线程是否被中断，不过 Thread.interrupted() 会同时将中断标识位改写为 false。

如果一个线程处于了阻塞状态（如线程调用了 thread.sleep()、thread.join()、thread.wait() 等），则在线程在检查中断标示时如果发现中断标示为 true，则会在这些阻塞方法调用处抛出 InterruptedException 异常，并且在抛出异常后会立即将线程的中断标示位清除，即重新设置为 false。

不建议自定义一个取消标志位来中止线程的运行。因为 run() 方法里有阻塞调用时会无法很快检测到取消标志，线程必须从阻塞调用返回后，才会检查这个取消标志。这种情况下，使用中断会更好，因为：1. 一般的阻塞方法，如 sleep 等本身就支持中断的检查；2. 检查中断位的状态和检查取消标志位没什么区别，用中断位的状态还可以避免声明取消标志位，减少资源的消耗。

注意：处于死锁状态的线程无法被中断

2.3 深入理解 run() 和 start()

Thread 类是 Java 里对线程概念的抽象，可以这样理解：我们通过 new Thread() 其实只是 new 出一个 Thread 的实例，还没有操作系统中真正的线程挂起钩来。只有执行了 start() 方法后，才实现了真正意义上的启动线程。

从 Thread 的源码可以看到，Thread 的 start() 方法中调用了 start0() 方法，而 start0() 是个 native 方法，这就说明 Thread.start() 一定和操作系统是密切相关的。

start() 方法让一个线程进入就绪队列等待分配 cpu，分到 cpu 后才调用实现的 run() 方法，start() 方法不能重复调用，如果重复调用会抛出异常（此处可能有面试题：多次调用一个线程的 start() 方法会怎么样？）。

而 run() 方法是业务逻辑实现的地方，本质上和任意一个类的任意一个成员方法并没有任何区别，可以重复执行，也可以被单独调用。

3. Java 中有几种方式创建一个线程？

大家在学习 Java 线程或者面试的时候，肯定见过这个问题。这个问题的答案也是众说纷纭，有 2 种、3 种、4 种等等答案。那么一起来看一下 Java 源码是怎么说的：

官方说法是在 Java 中有两种方式创建一个线程用以执行，一种是派生自 Thread 类，另一种是实现 Runnable 接口。

当然本质上 Java 中实现线程只有一种方式，都是通过 new Thread() 创建线程对象，调用 Thread.start() 启动线程。

至于基于 callable 接口的方式，因为最终是要把实现了 callable 接口的对象通过 FutureTask 包装成 Runnable，再交给 Thread 去执行，所以这个其实可以和实现 Runnable 接口看成同一类。

而线程池的方式，本质上是池化技术，是资源的复用，和新启线程没什么关系。

所以，比较赞同官方的说法，有两种方式创建一个线程用以执行。