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

main - main 线程，用户程序入口；
Reference Handler - 清除 Reference 的线程；
Finalizer - 调用对象 finalize 方法的线程；
Signal Dispatcher - 分发处理发送给 JVM 信号的线程；
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. 检查中断位的状态和检查取消标志位没什么区别，用中断位的状态还可以避免声明取消标志位，减少资源的消耗。

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