Java Thread 类创建线程的多种方式与线程终止详解

创建流程

1. 首先创建一个先继承 Thread 类，并重写 run 方法。
2. 在 main 方法中实例化一个 MyThread 类。
3. 调用 start() 方法来创建线程，并执行 run 方法里面的业务逻辑。

补充总结：由于我们在执行程序时，系统就会分配资源，自动创建进程，并且程序是需要调度执行，所以 main 方法自身就是一个线程：主线程。所以上述过程中，可以认为在主线程中又创建了一个线程。

逻辑分析

• run 中写着的是这个线程需要执行的 各种代码逻辑，相当于在 main 方法中的 代码同等含义。
• 虽然在上述代码中，没有直接调用重写的 run 方法，但是当我们调用 start() 方法后，在 Java 代码中会重新调用我们重写的 run 方法。
• 如果只是单纯的调用 run 方法，并不能创建线程。
• 对于上述过程有两个线程：主线程 和 myThread，都是分布在同一个系统资源下的，所以需要并发执行：两个死循环都不会相互制约，各自执行各自的。抢占执行：不能确定是哪个线程先执行到对应的逻辑。

补充细节：上述代码中，我们用到了 sleep() 方法，这个方法是 Thread 中的静态方法（类方法）。可以让程序休眠一段时间，调用这个目的：就是让程序猿好观察程序的执行过程。() 内参数 指定的是多少毫秒（ms），用于指定休眠多少时间，其中 1000 ms = 1s 换算进制。调用 sleep() 和创建线程的过程，都是需要抛出：InterruptedException 这个异常的。

其他创建方式

除了上述继承 Thread 重写 run 方法之外还有其他常见四种方式：

• 实现 Runnable 接口，重写 run 方法；
• 使用匿名内部类，对 Thread 类重写 run 方法；
• 使用匿名内部类，实现 Runnable 接口重写 run 方法；
• 使用 lambda 表达式，对匿名内部类进行简化。

实现 Runnable 接口

/**
 * 方法二：
 * 继承 Runnable
 * 实现 run 方法
 */
class MyThread1 implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("Runnable 中 run 线程 正在运行...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread myThread1 = new Thread(new MyThread1());
        myThread1.start();
        while (true) {
            System.out.println("main 线程 正在运行");
            Thread.sleep(1000);
        }
    }
}

主要的流程还是在实例化 Thread 对象之前：首先创建一个类 MyThread1 用于实现 Runnable 接口，重写 run 方法，最终 new 出对象 MyThread1 作为 Thread() 的参数进行传入进行实例化 Thread 对象即可。

匿名内部类——重写 Thread 的 run 方法

/**
 * 方法四：Thread 的匿名内部类
 * 在匿名内部类中重写 Run 方法
 */
class MyThread3 {
    public static void main(String[] args) throws InterruptedException {
        Thread myThread3 = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("匿名类 MyThread 的 run 线程 正在运行...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        // 创建线程
        myThread3.start();
        // 输出主线程
        while (true) {
            System.out.println("main 线程正在运行...");
            Thread.sleep(1000);
        }
    }
}

我们知道，对于匿名内部类来说，是一种不带引用的一种对象，也就是说当实例化 Thread 类对象时，我们使用匿名内部类的方式就是在 Thread() 后面加上 {}，并在 {} 内部重写 run 方法。

匿名内部类——实现 Runnable 接口的 run 方法

/**
 * 方法三：Runnable 的匿名内部类
 * 在匿名内部类中实现 Run 方法
 */
class MyThread2 {
    public static void main(String[] args) {
        Thread myThread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("内部类 Runnable 中 Run 方法正在执行...");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        // 创建线程
        myThread2.start();
        while (true) {
            System.out.println("主线程方法正在调用....");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

对于匿名内部类而言，使用的方式和上面一种方式相同，而在这里唯一的区别就在于，上面 new 出了 new Runnable 作为参数进行传入到 Thread 对象中。而本方式中，则是在 Thread 后面直接重写 run 方法。

使用 lambda 表达式简化匿名内部类

/**
 * 方法五：使用 lambda 表达式简化匿名内部类
 */
class MyThread4 {
    public static void main(String[] args) throws InterruptedException {
        Thread myThread4 = new Thread(() -> {
            while (true) {
                System.out.println("lambda 匿名类 MyThread 的 run 线程 正在运行...");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        // 创建线程
        myThread4.start();
        // 输出主线程
        while (true) {
            System.out.println("main 线程正在运行...");
            Thread.sleep(1000);
        }
    }
}

对于 lambda 表达式来说，最核心的部分就是把 new Runnable() {} 就是简化成 ()->{} 来使用，其实本质上还是通过匿名内部类实现 Runnable 接口的一种简化版本。

注意：对于 lambda 的使用，一定要注意一点的是：必须是函数式接口，也就是只有一个抽象方法的接口才能使用 lambda。

对于 start 创建线程来说，当调用 start 方法后，系统内核会生成 PCB 并且添加链表，创建新的线程。所以当多次调用 start 方法时，就会抛出异常，因为对于一个 Thread 对象来说，只能 start 一次，也就是说只能创建一个线程，这个原因也是为了 JVM 方便管理，否则一个 Thread 对象对应多个线程就会管理起来很复杂。

例如上述过程，就会抛出异常：IllegalThreadStateException。

上述总共五种创建线程的方式，都是蛮重要的，务必多操练多熟悉里面的代码流程和逻辑。

线程终止

线程终止初识

线程终止的方式有很多种，有粗暴的，也有温柔的。像粗暴的：让执行到一半的线程直接终止。像温柔的：让线程执行完整个任务才终止。对于 Java 来说，我们是下面这种方式，让线程执行完所有的任务才终止。

Java 线程终止的简易版

public class MyThread1 {
    public static boolean state = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (state) {
                System.out.println("hello Thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        // 创建线程
        t.start();
        Thread.sleep(3000);
        state = false;
    }
}

对于上述的流程主要是：

1. 首先定义一个布尔变量，用来确定线程的状态为 true（线程正在运行），为 false（线程结束）。
2. 其次在主线程中修改线程状态，让线程结束。注意这种结束的方式是让线程中的任务都执行结束了，当需要再次执行任务的时候才置为 false 的，是一种比较温柔的做法。

补充细节：如果把布尔类型放在 main 方法的内部呢？其实就会有问题，这归咎于我们的 Java 语法中有个小知识点：变量捕获。其实这种变量捕获是对于 lambda 表达式来说的，如果要在 lambda 表达式中使用同一作用域下的变量，这个变量是不可以被修改的。也就是说在上面的 state = false 出现了修改，所以 lambda 中就会编译失败。那么出现这种问题的比较好的解决方案就是把这个变量定义为成员变量，这样两种的作用域就不相同了，也从另外一个角度来看，内部的方法调用外部的成员是没有问题的。

Java 自身的线程终止方法

class Thread2 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 先获取当前线程
            Thread currentThread = Thread.currentThread();
            // 判断线程状态
            while (!currentThread.isInterrupted()) {
                System.out.println("hello thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });
        // 创建线程
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        // 修改线程状态
        t.interrupt();
    }
}

上述代码的流程主要分为以下几步：

• 实例化 Thread 对象，在 run 方法中使用 currentThread 方法来获取当前线程。
• 获取当前线程后，使用 isInterrupted 判断当前线程的状态，自身返回 false 代表线程正在进行，true 代表线程结束。
• 创建线程，并休眠指定时间，使用 interrupted 来修改 isInterrupted 为 true，让线程终止。
• 在 try-catch{} 在 catch 中添加 break，直接跳出循环。

代码分析

1. 如果 catch 中不添加 break，而是按照平常的写法：throw new RuntimeException(e); 直接抛出新的异常呢？情况就会变成这样，原因很简单，对于线程执行的时间来说，大部分时间是处于 sleep 的休眠状态，一旦有外面的线程来修改线程的状态，sleep 就会被打破休眠的状态，这时就会抛出异常，这时被 try-catch{} 捕获到，就会执行 throw new RuntimeException(e); 抛出新的异常，由于这个异常没有及时处理，编译器就会自动交给 JVM 来处理。所以我们不需要在 catch{} 写 throw new RuntimeException(e); 的方法。

2. 既然写 throw new RuntimeException(e); 会抛出新的异常，那么 catch 中什么都不写，break 也不写。会发生什么呢？如上图，就会出现即使我们使用 interrupted 来修改，但是线程还是会继续的情况。其实大家有所不知的是：对于休眠方法 sleep 是比较特殊的，一旦被唤醒，就会清除 isInterrupted 修改后的 true 状态，重新还原到 false 状态，这时线程就会继续执行了。所以这里如果我们要终止线程的话，就需要添加 break 来跳出。

假如有一天小编和女神去海边浪，此时小编这时坐在沙滩上打游戏，突然女神过来和说：我口渴了，你去买杯奶茶呗~ 这时就凸显我以后的家庭地位了，我就有三种选择：

1. 我听到之后没有理会，继续打我的游戏，从中就凸显我的'家庭帝位'；
2. 我立马停下手中的游戏，马上给女神买奶茶去，从中就凸显我的'家庭弟位'；
3. 我和她说：等我这把游戏打完，就给你去买，从中就凸显我的'家庭中位'。

而上述的栗子从中也反映了：终止线程过程中，虽然 sleep 能够清除 isInterrupt 修改后的状态，但是也为我们在 catch 中提供了多方面的选择，如果我们需要跳出就 break，如果需要继续执行就什么都不写，如果需要执行别的业务逻辑就添加进入即可。

总结

1. Thread 类：对于 Thread 类而言是 Java 封装的一种给系统创建线程的一个类的概念以及使用。
2. 创建线程的方式：掌握创建线程的主要流程和逻辑代码，以及熟悉这五种线程创建的方式。
3. 线程终止：对于线程终止的两种方式：强行终止的粗暴方式，等待任务结束的温柔方式。Java 的终止线程的方式是比较温柔并且操作空间是很大的。