多线程之interrupt(),isInterrupted()和interrupted()的区别以及线程中断机制

Thread提供了interrupt方法,用于中断线程或者查询线程中断状态.每个线程都有一个布尔类型的属性,表示线程的中断状态,当中断线程时将设置这个状态,当中断线程时,这个线程的中断状态将被设置为true.

---

• interrupt()方法能中断目标线程
• isInterrupted()能够返回目标线程的中断状态
• interrupted()将清除当前线程的中断状态,并且返回它之前的值,这是清除中断状态的唯一方法.

注意:

抛出InterruptedExceptions会清除线程中断状态，所以如果异常没有正确的处理异常，则会丢失中断状态的线程。

package com.springcloud.server.springserver.thread;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class TaskRunnable implements Runnable {
    BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
    @Override
    public void run() {
        try {
            System.out.println(queue.take());
        } catch (InterruptedException e) {
            System.out.println("捕捉到了InterruptedException~~~");
            System.out.println("线程此时的中断状态"+Thread.interrupted());
        }finally {
            System.out.println("线程finally的中断状态"+Thread.interrupted());
        }
    }

    public static void main(String[] args) {
        TaskRunnable taskRunnable = new TaskRunnable();
        Thread task = new Thread(taskRunnable);
        task.start();
        System.out.println("task线程的默认中断状态:"+task.isInterrupted());
        task.interrupt();
        System.out.println("interrupt后task线程的中断状态:"+task.isInterrupted());

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task线程的最终中断状态:"+task.isInterrupted());
    }
}

 输出结果:

1. main线程启动task线程,task线程的默认中断状态时false;
2. queue.take()方法在此阻塞,然后main线程调用task线程的interrupt()方法通知task线程中断,此时task线程的中断状态变成true;
3. 收到通知后take()方法便会抛出InterruptedException异常,在抛出异常的同时,此时线程的中断状态被清除,由true变成false;
4. 最终结果finally和休眠一秒后的主线程打印出task线程的都是false.

调用interrupt并不意味着立即停止目标线程正在进行的工作,而是传递了请求中断的消息

对于中断操作正确的理解是:它并不会真正的中断一个正在运行的线程,而只是发出一个中断请求,然后由线程在下一个合适的时候中断自己(这个时刻也被称为取消点).有些方法,例如wait、sleep和join等,将严格的处理这种请求,当他们收到中断请求或者在开始执行时发现某个已经被设置好了的中断状态时,将抛出一个异常.

在使用静态的interrupted时应该小心,因为它会清除当前线程的中断状态.如果在调用interrupted时返回了true,那么除非你想屏蔽这个中断,否则必须对它进行处理----可以抛出InterruptedException或者再次调用interrupt来回复中断状态.

当在代码中调用了一个将抛出InterruptedException异常的方法时,你自己的方法也就变成了一个阻塞方法,并且必须要处理对中断的响应.对于代码库来说,有两种基本选择:

• 传递InterruptedException.

可以将InterruptedException传递给方法的调用者.传递InterruptedException异常的方法包括:不捕捉该异常;捕捉该异常,然后再进行简单的逻辑清理工作之后再次抛出该异常.

public class TaskRunnable implements Runnable {
    BlockingQueue<String> queue = new LinkedBlockingQueue<String>();
    @Override
    public void run() {
        try {
            getNextString();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getNextString() throws InterruptedException {
        return queue.take();
    }
}

take()方法是一个阻塞方法,getNextString方法调用take()阻塞方法,它不处理这个异常,直接将异常抛出,谁调用我就自己处理这个异常.

• 恢复中断

有时候不能抛出InterruptedException,例如当代码是Runnable的一部分时.在这些情况下,必须捕获InterruptedException,并通过调用该线程上的interrupt()方法恢复中断.

在恢复中断的情况下,我参考了另外一篇博客,发现其博客有误导人的倾向(个人拙见),特此提出:

https://blog.csdn.net/VincentGTX_huang/article/details/106410889

我改造后的代码如下:

package com.springcloud.server.springserver.thread;

public class RightWayInterruptPro2 implements  Runnable {

    @Override
    public void run() {
        //如果中断了,则跳出执行
        while(true){
            //入口1
            if(Thread.currentThread().isInterrupted()){
                System.out.println("收到中断停止执行");
                break;
            }

            try {
                //入口2
                Thread.sleep(1);
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().isInterrupted());
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) {
        Thread thread=new Thread(new RightWayInterruptPro2());
        thread.start();
        try {
            //先休眠,然后再让线程中断
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();
        System.out.println("开始线程状态"+thread.isInterrupted());
        try {
            //先休眠,然后再让线程中断
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("最终线程状态"+thread.isInterrupted());
    }
}

原博客休眠时间是5000毫秒和1000毫秒,其实这是一个意思,就是执行两个sleep的时间相同罢了,在这里我进行了尝试,当sleep的毫秒数越小的时候,越不容易发生线程无法中断的情况.其实这里就是当main线程调用interrupt()方法的时候,执行的while循环里面有两个入口,

有可能在入口1,此时便会跳出循环,并且线程的状态一直是true,无法被清除;

有可能在入口2,此时由于捕捉了InterruptedException,那么线程的中断状态会被清除,返回false,打印一次异常栈之后,在while循环里面无法跳出,线程无法结束.

两种结果:

由于两种情况是由cpu进行分配时间片的,人工无法预料,那么最正确的做法就是在捕捉了InterruptedException的时候,在catch块里面再次调用interrupt()恢复中断状态,这也是大多数的做法.