停止线程的场景

停止线程的场景有很多种，这里列举几种：

程序需要退出或者终止：当程序需要退出或者终止时，需要停止所有的线程，释放资源。
资源被占用：当线程运行时占用了某些资源，而其他线程需要使用这些资源时，需要停止线程来释放这些资源。
等待超时：当线程等待某个事件的发生，但是等待时间超过了预定的时间，需要停止线程并执行下一步操作。
线程已经完成任务：在某些情况下，线程已经完成了它的任务，不再需要继续运行，需要停止线程并释放资源。
线程出现异常：当线程发生异常时，需要停止线程以避免出现不一致的状态。
程序性能不佳：当线程的运行影响了程序的性能或者导致程序崩溃时，需要停止线程以避免这种情况的发生。

线程可以强制停止，也可以优雅停止。

强制停止线程

强制停止线程顾名思义就是直接终止线程的执行，不管现在在做什么操作。

可以调用Thread.stop() 方法来强制终止一个线程。但是，这种方式已经过时并且是不安全的，因为它会直接终止线程的执行，导致线程没有机会清理资源或者处于不一致的状态。因此，不推荐使用该方法来停止线程。

优雅停止线程

优雅地停止线程是指一种安全、有效的方式，用于终止一个正在运行的线程，让线程在停止前能够完成必要的清理工作，避免出现不一致的状态，确保程序的正确性和稳定性。

通常有两种方式来优雅地停止线程：使用标志位和使用 interrupt() 方法

使用标志位

使用标志位是在线程的 run() 方法中添加一个标志位，用于控制线程的执行。当标志位变为停止状态时，线程会正常退出。

以下是一个使用标志位停止线程的代码示例：

class MyThread extends Thread {
    // 定义标志位
    private volatile boolean stop = false;

    @Override
    public void run() {
        while (!stop) {
            // 执行任务
        }
        // 执行必要的清理工作
    }

    // 设置标志位为 true，停止线程
    public void stopThread() {
        stop = true;
    }
}

在上面的示例中，我们定义了一个 stop 标志位，用于控制线程的执行。在线程的 run() 方法中，我们不断地检查标志位，如果标志位为 true，则退出循环，执行必要的清理工作。在 stopThread() 方法中，我们设置标志位为 true，从而停止线程的执行。

需要注意的是，为了确保不同线程之间的可见性，我们需要使用 volatile 关键字来修饰标志位，这样能够保证线程在读取和写入标志位时，能够正确地同步数据。

使用标志位这种方式其实就是一种思想，比如你也可以在符合条件的时候使用return或者其他操作停止线程，这都是可以的。

使用interrupt()方法

使用 interrupt() 方法来中断线程的执行，调用该方法会设置线程的中断状态为 true，但并不会强制停止线程的执行。线程在收到中断信号后，可以在适当的时候做好必要的清理工作并退出，也就是说当调用 interrupt() 方法之后只是给线程下达一个中断的命令，线程是否响应中断请求取决于具体的代码实现。

像下面这段代码，在run()方法判断线程状态，如果线程状态为true就return，这样就能响应中断请求了。

public class MyThread extends Thread {
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            // 线程执行的代码
            // 检测线程的中断状态
            if (Thread.currentThread().isInterrupted()) {
                // 如果接收到中断请求，则终止线程的执行
                return;
            }
        }
    }
}

我们可以调用interrupted() 和 isInterrupted() 方法检测线程的中断状态，它们之间有以下区别：

interrupted() 方法是一个静态方法，它用于检测当前线程的中断状态，并清除中断状态。也就是说，如果当前线程的中断状态为 true，则 interrupted() 方法返回 true，同时会将中断状态清除为 false；如果当前线程的中断状态为 false，则 interrupted() 方法返回 false。
isInterrupted() 方法是一个实例方法，它用于检测线程对象的中断状态，但不清除中断状态。也就是说，如果线程对象的中断状态为 true，则 isInterrupted() 方法返回 true；如果线程对象的中断状态为 false，则 isInterrupted() 方法返回 false。

另外，需要注意的是，interrupted() 方法会将中断状态清除为 false，因此在使用 interrupted() 方法时需要注意保留中断状态，以便于其他地方继续使用。而 isInterrupted() 方法不会清除中断状态，因此可以反复地使用该方法来检测线程的中断状态。

以下是一个使用 interrupt() 方法停止线程的代码示例：

class MyThread extends Thread {

    @Override
    public void run() {

        for (int i = 0;  !Thread.currentThread().isInterrupted(); i++) {
            System.out.println("线程运行中==="+i);
            if (i == 5){
                //中断线程
                interrupt();
            }
        }
        System.out.println("before isInterrupted="+isInterrupted());
        System.out.println("before interrupted="+Thread.interrupted());
        System.out.println("after isInterrupted="+isInterrupted());
        System.out.println("after interrupted="+Thread.interrupted());
    }
}

class InterruptTest{

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

运行结果如下：

线程运行中===0
线程运行中===1
线程运行中===2
线程运行中===3
线程运行中===4
线程运行中===5
before isInterrupted=true
before interrupted=true
after isInterrupted=false
after interrupted=false

在上面的例子中，我们启动一个线程MyThread，并在它的run()方法中判断如果 i == 5 就调用 interrupt()方法中断线程，最后打印线程的状态。因为调用 interrupt() 方法之后线程的中断状态为 true，所以 before isInterrupted 和 before interrupted都为true，在调用 Thread.interrupted()方法之后中断状态清除为 false，所以 after isInterrupted 和 after interrupted都为false。

通常情况下，如果线程处于阻塞状态（例如调用 sleep()、wait()、join() 等方法），则会抛出 InterruptedException 异常，并且清除线程的中断状态。在抛出 InterruptedException 异常后，线程会恢复到可运行状态，可以继续执行，如果想在异常后中断线程执行，要调用interrupt() 方法，就如下面这段代码一样，异常后中断线程执行。

class MyThread extends Thread {
    @Override
    public void run() {
        try {
            while (!Thread.currentThread().isInterrupted()) {
                // 执行任务
            }
        } catch (InterruptedException e) {
            // 设置线程的中断状态
            Thread.currentThread().interrupt();
            // 根据具体需求，决定如何继续处理线程中断
            // ...
        }
        // 执行必要的清理工作
    }
}