如何优雅正确地通过interrupt方法中断线程

为什么废弃Thread的stop函数？

简单来说就是stop方法中断线程太过暴力随意，且会是否线程持有的锁，会导致线程安全问题。还有可能导致存在需要被释放的资源得不到释放，引发内存泄露。所以用stop停止线程是不推荐的。

1. stop是通过立即抛出ThreadDeath异常，来达到停止线程的目的，此异常抛出有可能发生在任何一时间点，包括在catch、finally等语句块中，但是此异常并不会引起程序退出。
2. 由于有异常抛出，导致线程会释放全部所持有的锁，极可能引起线程安全问题。
3. 有可能导致存在需要被释放的资源得不到释放，引发内存泄露。

使用Thread的interrupt()方法结束线程

调用Thread对象的interrupt函数并不是立即中断线程，只是将线程中断状态标志设置为true，当线程运行中有调用其阻塞的函数（Thread.sleep，Object.wait，Thread.join等时，像Thread.sleep()方法调用之后，会不断地轮询检测中断状态标志是否为true，如果为true，则停止阻塞并抛出InterruptedException异常，同时还会重置中断状态标志false；如果为false，我们在catch方法体里没有重新interrupt()把在中断状态标志设置为true的话，就会导致循环体无需循环下去，可参考下面的代码。

注意事项：

• 使用isInterrupted来判断线程是否处于中断状态，若是中断状态，则跳出正在执行的任务，使线程结束运行。
• 调用sleep()方法触发InterruptedException异常时，在catch代码块中需再次调用interrupt()方法，使线程再次处于中断状态，使while循环条件为false，使线程跳出循环，结束运行。若不调用，while循环为死循环，线程无法结束。

代码示例

public class InterruptTest {

    /**
     * 结束未使用阻塞函数的线程
     * @throws InterruptedException
     */
    @Test
    public void test1() throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("开始搬砖！");
            //只要代码里没有异常，那么我们可以通过判断线程是否中断来执行业务操作
            //当其他线程发出线程中断信号后就会跳出正在执行的任务，往下执行使线程结束运行。
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("西西弗斯的陷阱：无脑循环，日复一日搬砖！");
            }
            System.out.println("神迹出现，结束搬砖！");
            System.out.println(Thread.currentThread().isInterrupted());//true
        });
        thread.start();
        TimeUnit.MILLISECONDS.sleep(10);
        System.out.println("启动超级进化形态！");
        thread.interrupt();
    }
    /**
     * 开始搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 。。。。。
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 启动超级进化形态！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 神迹出现，结束搬砖！
     */

    /**
     * 结束使用阻塞函数的线程
     * @throws InterruptedException
     */
    @Test
    public void test2() throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("开始搬砖！");
            //只要代码里没有异常，那么我们可以通过判断线程是否中断来执行业务操作
            //当其他线程发出线程中断信号后就会跳出正在执行的任务，往下执行使线程结束运行。
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("西西弗斯的陷阱：无脑循环，日复一日搬砖！");
                try {
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println(Thread.currentThread().isInterrupted());//false
                    Thread.currentThread().interrupt();
                    System.out.println(Thread.currentThread().isInterrupted());//true
                }
            }
            System.out.println("神迹出现，结束搬砖！");
        });
        thread.start();
        TimeUnit.MILLISECONDS.sleep(1000);
        System.out.println("启动超级进化形态！");
        thread.interrupt();
        //主线程加上这个睡眠时间是为了便于查看当没有在catch代码块中需调用interrupt函数，使线程再次处于中断状态，
        // 使while循环条件为false，使线程跳出循环，结束运行。若不调用，while循环为死循环，线程无法结束。
        TimeUnit.SECONDS.sleep(3000);
    }
    /**
     * catch中有调用 Thread.currentThread().interrupt();
     * 开始搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 启动超级进化形态！
     * java.lang.InterruptedException: sleep interrupted
     *  at java.lang.Thread.sleep(Native Method)
     *  at java.lang.Thread.sleep(Thread.java:340)
     *  at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
     *  at cn.vv.schedule.module.rewardpunishment.service.InterruptTest.lambda$test2$1(InterruptTest.java:64)
     *  at java.lang.Thread.run(Thread.java:748)
     * 神迹出现，结束搬砖！
     */

    /**
     * catch中没有调用 Thread.currentThread().interrupt();线程会无需循环下去，直到主线程结束
     *开始搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 启动超级进化形态！
     * java.lang.InterruptedException: sleep interrupted
     *  at java.lang.Thread.sleep(Native Method)
     *  at java.lang.Thread.sleep(Thread.java:340)
     *  at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
     *  at cn.vv.schedule.module.rewardpunishment.service.InterruptTest.lambda$test2$1(InterruptTest.java:64)
     *  at java.lang.Thread.run(Thread.java:748)
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 西西弗斯的陷阱：无脑循环，日复一日搬砖！
     * 。。。。。。一直下去
     */

}

Thread的静态函数interrupted与Thread的对象函数isInterrupted比较

静态方法Thread.interrupted()会在检测线程中断状态标志是否为true后，还会将中断状态标志重置为false。

对象方法thread.isInterrupted()只是检测线程中断状态标志。

//静态方法
public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
//对象方法
public boolean isInterrupted() {
    return isInterrupted(false);
}

/**
     * Tests if some Thread has been interrupted.  The interrupted state
     * is reset or not based on the value of ClearInterrupted that is
     * passed.
     */
//ClearInterrupted表示是否清除中断标示状态，清除后为false
private native boolean isInterrupted(boolean ClearInterrupted);

参考

Java线程中断的理解和正确使用