并发编程之线程中断interrupt

线程中断可能在平时的开发中我们用的不多，但是我相信大部分都见过InterruptedException，因为不管我们在调用object.wait()还是Thread.sleep()都会抛出一个InterruptedException。可能有很多人都是直接的继续抛出去或者不做任何处理直接打印堆栈信息，当然有可能这样没有问题，但是有些业务我们这样处理并不适合。要弄懂这些，我们就需要知道interrupt的作用是什么。

一、如何让线程停止

如果我们需要让一个线程停止，我们可以用什么方法呢？我们今天先不讨论那种过时的stop方法，这也不推荐使用，原因是因为太暴力了，它会直接将线程中断，不管你的线程资源是否释放。我在这里描述过我见过的其他两种方式：

• 自己定义一个volatile的boolean类型的变量控制
• 使用thread.interrupt

1、使用自定义的volatile的boolean变量控制

package com.taolong.concurrent.interrupt;

/** * @Author * @Version 1.0 * @Description 自己控制线程终端 */
public class MyselfInterruptTest {
   


    public static void main(String[] args) {
   

        MyThread task = new MyThread();

        task.start();

        //先让task跑10秒钟
        try {
   
            Thread.sleep(10000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        //终止task
        task.setStop(true);

    }




    static class MyThread extends Thread{
   
        private volatile boolean stop;

        @Override
        public void run() {
   
            while(!stop){
   
                System.out.println("continue run.....");
            }
            System.out.println("--->i will stop...");
        }


        public boolean isStop() {
   
            return stop;
        }

        public void setStop(boolean stop) {
   
            this.stop = stop;
        }
    }
}

2、使用自带的interrupt

package com.taolong.concurrent.interrupt;

/** * @Version 1.0 * @Description 使用interrupt终止 */
public class UseInterruptTest {
   

    public static void main(String[] args) {
   
        Thread task = new Thread(new MyInterruptRunnable());

        task.start();

        //先让task跑10秒钟
        try {
   
            Thread.sleep(10000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        //终止task
        task.interrupt();
    }

    static class MyInterruptRunnable implements Runnable{
   

        @Override
        public void run() {
   
            while(!Thread.currentThread().isInterrupted()){
   
                System.out.println("continue run.....");
            }
            System.out.println("--->i will stop...");
        }

    }
}

两个执行的结果是一样的，都是执行10s后终止

虽然执行的结果相同，但是这只是简单的使用，后面我们继续看一下稍微改变一下代码看看会发生什么变化。

我们现在让任务每隔3s打印一次，修改的代码如下：

public void run() {
   
    while(!Thread.currentThread().isInterrupted()){
   
        System.out.println("continue run.....");
        //每隔3秒打印一次
        try {
   
            Thread.sleep(3000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
    }
    System.out.println("--->i will stop...");
}

（1）使用自定义的变量控制打印的结果

（2）使用interrupt控制的打印结果

这个时候两个打印的结果就不一样了，而且使用interrupt中断的时候，下面并没有中断任务。为什么会产生这样的情况呢？如果不太了解interrupt的使用，是不是容易出错（如果我们真的在这里需要中断业务）。

二、Interrupt使用的正确姿势

前面我们通过两种方法来实现线程中断的操作，可以看出来基本上都能够满足，但是还是有一些差别，尤其是对interrupt的使用，可能会出现跟我们预期的不一致的情况。现在我们就来看看Interrupt到底如何使用。

1、首先需要理解的是interrupt主要是给线程发送一个中断信号，并不会强迫线程立即停止（这也是为什么不使用stop的原因）—理解这一点非常重要

从我们上面的例子可以看出，我们通过在run方法中增加if的逻辑判断去控制线程的中断，如果让我们不加这个if判断的时候，即便我们调用了thread.interrupt()方法，线程也不会中断，而是会继续执行，感兴趣的可以自行编写代码进行测试。

2、线程中断相关的几个方法的介绍和使用interrupt()、isInterrupted()、interrupted()

interrupt()：向线程发送一个中断信号标志，至于是否真正中断，要看该线程的具体逻辑

isInterrupted()：判断线程是否中断标志，其实就是获取了这个中断标志的值

interrupted()：获取了线程的中断信号，但是会清除中断标志位，比如一开始中断标志位为false，后面调用interrupt()将中断标志位设置成true，此时如果调用interrupted()返回的true，但是同时它会将中断标志位置为false，那么下次不管调用isInterrupted()或者是interrupted()返回的都是false

虽然上面三个方法可以控制中断标志位，但是它仅仅是一个变量，它不会直接影响我们的线程的中断。我们必须要自己根据这个变量去控制线程的中断与否。

前面一节的例子中已经说明了interrupt()、isInterrupted()的基本使用，其实可以当作一个基本的boolean类型判断即可。当调用interrupt()产生异常时，则不能将标志位置为true，我们通过代码打印看一下

package com.taolong.concurrent.interrupt;

/** * @Version 1.0 * @Description 使用interrupt终止 */
public class UseInterruptTest {
   

    public static void main(String[] args) {
   
        Thread task = new Thread(new MyInterruptRunnable());

        task.start();

        //先让task跑10秒钟
        try {
   
            Thread.sleep(10000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        //发起线程中断信号
        task.interrupt();
    }

    static class MyInterruptRunnable implements Runnable{
   

        @Override
        public void run() {
   
            while(!Thread.currentThread().isInterrupted()){
   
                System.out.println("continue run.....");
                //每隔3秒打印一次
                try {
   
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
   
                    e.printStackTrace();
                    //看看中断标志位结果
                    System.out.println("interrupt=" + Thread.currentThread().isInterrupted());
                }
            }
            System.out.println("--->i will stop...");
        }

    }
}

打印结果：

从日志中可以看出，中断标志位是false（之前在main方法中的task.interrupt()没生效），如果我们真的需要把正在thread中执行的任务终止掉怎么办呢，可以在catch中调用interrupt()方法，我们试试

catch (InterruptedException e) {
   
    e.printStackTrace();
    //看看中断标志位结果
    System.out.println("interrupt=" + Thread.currentThread().isInterrupted());
    Thread.currentThread().interrupt();
    System.out.println("after invoke interrupt() interrupt=" + Thread.currentThread().isInterrupted());
}

执行结果：

我们通过在catch中重新设置中断标志位，做到了终止线程的作用，并且中断标志位变成了true

这个时候可能有人会心里想，这比使用自己定义的volatile的boolean类型的变量要麻烦一点，但是仔细思考真的是这样子的吗？—答案显然不是如此，不然jdk也没必要提供interrupt的方法了，比如可以看下面的场景：

1、自定义的volatile的boolean变量能及时相应在阻塞时中断的操作吗（比如当线程正在wait()、sleep()时）
2、自定义的volatile的boolean变量能检测出中断异常、并且根据异常判断任务是否真的需要被中断吗

这个时候发现自定义的变量控制线程中断只能满足一些比较简单的业务，而使用interrupt不仅覆盖了自定义变量的功能，而且还有更强大的功能，所以我们在选择上，建议尽量选择interrupt。

上面还有一个interrupted()方法没有写测试用例，原本想感兴趣的自行测试，在这里也简单的贴一下代码吧

while(!Thread.currentThread().isInterrupted()){
   
    System.out.println("continue run.....");
    //每隔3秒打印一次
    try {
   
        Thread.sleep(3000);
    } catch (InterruptedException e) {
   
        e.printStackTrace();
        //看看中断标志位结果
        System.out.println("interrupt=" + Thread.currentThread().isInterrupted());
        Thread.currentThread().interrupt();//true
        System.out.println("after invoke interrupt() interrupt=" + Thread.currentThread().isInterrupted());
        //使用interrupted(),查看中断标志位
        System.out.println("使用interrupted()判断是否中断 interrupt=" + Thread.interrupted());//返回true，但是会清除，下一次调用为false
        //调用interrupted()后,查看是否会清除标志位
        System.out.println("after invoke interrupted() interrupt=" + Thread.currentThread().isInterrupted());//false
    }
}

打印结果：

这里对结果稍微解析一下：

1、首先interrupt=false，说明在主线程调用t.interrupt()产生的异常导致并没有中断线程，而且走到了catch

2、当在catch再次调用interrupt()时，表示将中断标注位置为了true

3、当interrupted()判断中断标志位=true—2产生的结果

4、当interrupted()调用后会清除中断标志位=false—-3调用intterupted()清除了标志位

5、此时线程被interrupted()清除后，线程标志位依然是false，while循环判断依然=true，则最终线程未中断

相信大家对interrupt的使用已经比较熟悉了，后面可以根据自己的业务情况判断是否真的需要中断线程哦。