线程中断是怎么回事

线程中断相关方法

Thread.interrupt()--设置线程中断状态，true

Thread.isInterrupted();--判断线程的中断状态

Thread.interrupted();---返回线程的中断状态，并清除，下次再判断中断状态就是false

public boolean isInterrupted() {  
    return isInterrupted(false);  
}

public static boolean interrupted() {  
    return currentThread().isInterrupted(true);  
}
//调用同一个方法，只是传参不同,是否清除中断标识
private native boolean isInterrupted(boolean ClearInterrupted);

interrupted 静态方法会把原本线程的中断状态清除，而 isInterrupted 则不会。

下面证明一下 interrupt 方法只是设置一个中断状态，而不是使当前线程中断运行:

Thread t = new Thread(new Runnable(){
    @Override
    public void run() {
        System.out.println("线程中断标志（中断前）:"+Thread.currentThread().isInterrupted());
        while (flag){

        }
        System.out.println("标志flag为:" + flag);
        System.out.println("线程中断标志(不清除):"+Thread.currentThread().isInterrupted());
        System.out.println("线程中断标志(清除):"+Thread.interrupted());
        System.out.println("线程中断标志(不清除):"+Thread.currentThread().isInterrupted());
        System.out.println("我还在继续执行");
    }
});

t.start();
Thread.sleep(100);
flag = false;
t.interrupt();


---
线程中断标志（中断前）:false
标志flag为:false
线程中断标志(不清除):true----1
线程中断标志(清除):true
线程中断标志(不清除):false----2
我还在继续执行

sleep 响应中断

线程中常用的阻塞方法，如sleep，join和wait 都会响应中断，然后抛出一个中断异常 InterruptedException。但是，注意此时，线程的中断状态会被清除。所以，当我们捕获到中断异常之后，应该保留中断信息，以便让上层代码知道当前线程中断了。通常有两种方法可以做到。

一种是，捕获异常之后，再重新抛出异常，让上层代码知道。

另一种是，在捕获异常时，通过 interrupt 方法把中断状态重新设置为true。

public class TestInterrupt {
    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(new Runnable() {
            private int count = 0;
            @Override
            public void run() {
                try {
                    count = new Random().nextInt(1000);
                    count = count * count;
                    System.out.println("count:"+count);
                    Thread.sleep(5000);
                } catch (Exception e) {
                    System.out.println(Thread.currentThread().getName()+"线程第一次中断标志："+Thread.currentThread().isInterrupted());
                    //重新把线程中断状态设置为true，以便上层代码判断
                    Thread.currentThread().interrupt();
                    System.out.println(Thread.currentThread().getName()+"线程第二次中断标志："+Thread.currentThread().isInterrupted());
                }
            }
        });

        t.start();

        Thread.sleep(100);
        t.interrupt();
    }
}


-----
count:337561
Thread-0线程第一次中断标志：false---被清除了
Thread-0线程第二次中断标志：true

LockSupport方法介绍

LockSupport 方法中重要的两个方法就是park 和 unpark 。

park和interrupt中断

park方法可以阻塞当前线程，如果调用unpark方法或者中断当前线程，则会从park方法中返回。

park方法对中断方法的响应和 sleep 有一些不太一样。它不会抛出中断异常，而是从park方法直接返回，不影响线程的继续执行。

当调用interrupt方法时，会把中断状态设置为true，然后park方法会去判断中断状态，如果为true，就直接返回，然后往下继续执行，并不会抛出异常。注意，这里并不会清除中断标志，调用unPack会清除中断标记。

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new ParkThread());
        t.start();
        Thread.sleep(100); //①
        System.out.println(Thread.currentThread().getName()+"开始唤醒阻塞线程");
        t.interrupt();
        System.out.println(Thread.currentThread().getName()+"结束唤醒");
        t.interrupt();
    }
}

class ParkThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始阻塞");
        LockSupport.park();
        System.out.println("线程中断标志(不清除):"+Thread.currentThread().isInterrupted());
        Thread.interrupted();//清除中断标识---然后会继续阻塞
        System.out.println("线程中断标志(不清除):"+Thread.currentThread().isInterrupted());
        System.out.println(Thread.currentThread().getName()+"第一次结束阻塞");
        LockSupport.park();
        System.out.println("第二次结束阻塞");
    }
}

----
Thread-0开始阻塞
main开始唤醒阻塞线程
main结束唤醒
线程中断标志(不清除):true
线程中断标志(不清除):false-----因为中断标记清除了，所以再次调用park方法就会阻塞
Thread-0第一次结束阻塞

unpark

unpark只是给当前线程设置一个许可证。如果当前线程已经被阻塞了（即调用了park），则会转为不阻塞的状态。unpark方法会清除中断标识，下次再次调用park方法，依然会阻塞。即使设置多次unpark，许可证最多只有一个，也不会增加许可证。

public class LockSupportTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new ParkThread());
        t.start();
        Thread.sleep(100); //①
        System.out.println(Thread.currentThread().getName()+"开始唤醒阻塞线程");
        //        t.interrupt();
        LockSupport.unpark(t);
        LockSupport.unpark(t);
        System.out.println(Thread.currentThread().getName()+"结束唤醒");
    }
}

class ParkThread implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始阻塞");
        LockSupport.park();
        System.out.println("线程中断标志(不清除):"+Thread.currentThread().isInterrupted());
        //Thread.interrupted();//清除中断标识
        System.out.println("线程中断标志(不清除):"+Thread.currentThread().isInterrupted());
        System.out.println(Thread.currentThread().getName()+"第一次结束阻塞");
        LockSupport.park();
        System.out.println("第二次结束阻塞");
    }
}

---
第二个park会阻塞

 

park/unpark和 wait/notify区别

了解了 park/unpark的用法之后，想必你也能分析出来它们和 wait、notify有什么不同之处了。

1) wait和notify方法必须和同步锁 synchronized一块儿使用。而park/unpark使用就比较灵活了，没有这个限制，可以在任何地方使用。

2) park/unpark 使用时没有先后顺序，都可以使线程不阻塞（前面代码已验证）。而wait必须在notify前先使用，如果先notify，再wait，则线程会一直等待。

3) notify只能随机释放一个线程，并不能指定某个特定线程，notifyAll是释放锁对象中的所有线程。而unpark方法可以唤醒指定的线程。

4) 调用wait方法会使当前线程释放锁资源，但使用的前提是必须已经获得了锁。而park不会释放锁资源。（以下代码验证）

public class LockSyncTest {
    private static Object lock = new Object();
    //保存调用park的线程，以便后续唤醒
    private static Thread parkedThread;

    public static void main(String[] args) throws InterruptedException {

        Thread t1 = new Thread(()->{
             synchronized (lock){
                 System.out.println("unpark前");
                 LockSupport.unpark(parkedThread);
                 System.out.println("unpark后");
             }
        });

        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                //和t1线程用同一把锁时，park不会释放锁资源，若换成this锁，则会释放锁
                synchronized (lock){
                    System.out.println("park前");
                    parkedThread = Thread.currentThread();
                    LockSupport.park();
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("park后");
                }
            }
        });

        t2.start();
        Thread.sleep(100);
        t1.start();

    }
}
//打印结果
//park前

以上代码，会一直卡在t2线程，因为park不会释放锁，因此t1也无法执行。

如果把t2的锁换成this锁，即只要和t1不是同一把锁，则t1就会正常执行，然后把t2线程唤醒。打印结果如下：

park前
unpark前
unpark后
park后

注意：

LockSupport.park()会让当前线程进入阻塞状态，并且在阻塞时会让出CPU资源。在线程被阻塞期间，它会主动让出CPU资源，即暂停执行，并且不会占用CPU时间片。这与普通的自旋锁或忙等待不同，自旋锁会一直占用CPU资源进行忙等待，而LockSupport.park()是一种主动让出CPU资源的等待方式。

参考文章：

https://cloud.tencent.com/developer/article/1645909