五、LockSupport与线程中断locksupport 是 JUC.locks下的一个类一、线程中断机制如何中断

locksupport 是 JUC.locks下的一个类

一、线程中断机制

如何中断一个线程？

如何停止一个线程？

首先

一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己来决定自己的命运。

所有，Thread.stop，Thread.suspend，Thread.resume都已经被废弃了。

其次

在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。

因此，Java提供了一种用户停止线程的协商制作---中断，也即中断标识协商机制。

中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全程序员自己实现。

若要中断一个线程，你需要手动调用该线程的interrupt方法，该方法也仅仅是将线程对象的中断标识设为true；

每个线程对象中都有一个中断标识位，用户标识线程是否被中断；该标识位为true标识中断，为false

标识未中断；通过调用线程对象的interrupt方法将该线程的标识位设为true，可以别的线程中调用，也可以在自己的线程中调用。

1.interrupt（）

实例方法：

实例方法interrupt（）仅仅是设置线程的中断状态为true，发起一个协商而不会立刻停止线程

2.interrupted()

静态方法： Thread.interrupted()

判断线程是否被中断并清除当前中断状态。

这个方法做了两件事：

1.返回当前线程的中断状态，测试当前线程是否已被中断

2.将当前线程的中断状态清零并重新设为false，清除线程的中断状态

此方法有点不好理解，如果连续两次调用此方法，则第二次调用将返回false，因为连续调用两次的结果可能不一样

3.isInterrupted()

实例方法

判断当前线程是否被中断（通过检查中断标志位）

大厂面试题中断机制考点

1.如何停止中断运行中的线程

A.通过一个volatile变量实现

package com.lyj.sc.duoThread.interrput;

import java.util.concurrent.TimeUnit;

/**
 * @Author: liyangjing
 * @Date: 2022/08/13/12:10
 * @Description:
 */
public class InterruptDemo {
    static volatile boolean isStop = false;

    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (true){
                if(isStop){
                    System.out.println(Thread.currentThread().getName()+"\tisStop的值被修改为ture，程序停止");
                    break;
                }
                System.out.println("-----hello volatile");
            }
        },"t1").start();
        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(()->{
            isStop=true;
        },"t2").start();
    }
}

两个线程通过标志位来控制。

B.通过AtomicBoolean

原子布尔型

    public static void m1_atomicBoolean() throws InterruptedException {
        new Thread(()->{
            while (true){
                if(atomicBoolean.get()){
                    System.out.println(Thread.currentThread().getName()+"\tisStop的值被修改为ture，程序停止");
                    break;
                }
                System.out.println("-----hello volatile");
            }
        },"t1").start();
        //暂停毫秒
        TimeUnit.MILLISECONDS.sleep(20);

        new Thread(()->{
            atomicBoolean.set(true);
        },"t2").start();
    }

C.通过Thread类自带的中断api实例方法实现

思想：和用volatile变量和Atomic原子类一样， 在需要中断的线程不断监听中断状态，一旦发生中断，就执行相应的中断处理业务逻辑stop线程

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (true) {
                //获取当前线程是否被中断过
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "\tisStop的值被修改为ture，程序停止");
                    break;
                }
                System.out.println("-----hello interrupt api");
            }
        }, "t1");
        t1.start();

        TimeUnit.MILLISECONDS.sleep(20);
        new Thread(()->{
            t1.interrupt();
        },"t2").start();
    }

System.out.println("t1默认中断标志位"+t1.isInterrupted());

实例方法 interrupt() ,没有返回值

实例方法 isInterrupted() ，返回布尔值

4.总结

具体来说，当对一个线程，调用interrupt()时；

如果线程处于正常活动状态，那么会将该线程的中断标志设置为true，仅此而已，被设置中断标志的线程将继续正常运行，不受影响。 所以，interrupt() 并不能真正的中断线程，需要被调用的线程自己进行配合才行。
如果线程处于被阻塞状态（例如处于sleep、wait、join等状态），在别的线程中调用当前对象的interrupt方法，那么线程将立即退出被阻塞状态，并抛出一个interruptException异常。

2.当前线程的中断表示为true，是不是线程就立刻停止

对不活动的线程不会造成任何影响

public class InterruptDemo2 {

    public static void main(String[] args) throws InterruptedException {
        //实例方法interrupt()仅仅时设置线程的中断状态位为ture
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <= 300; i++) {
                System.out.println("-------" + i);
            }
            System.out.println("t1线程调用interrupt()后 的中断标识02："+Thread.currentThread().isInterrupted());//true
        }, "t1");
        t1.start();

        System.out.println("t1线程调用interrupt()后 的中断标识01："+t1.isInterrupted());//false

        //暂停毫秒

        TimeUnit.MILLISECONDS.sleep(2);

        t1.interrupt();//true
        System.out.println("t1线程调用interrupt()后 的中断标识02："+t1.isInterrupted());//true

        TimeUnit.MILLISECONDS.sleep(2000);
        System.out.println("t1线程调用interrupt()后 的中断标识02："+t1.isInterrupted());//false 对不活动的线程不会产生任何影响
    }
}

1 中断标志位，默认为false

2 t2 ----》 t1发出了中断协商， t2调用t1.interrupt（），中断标志位true

3.中断标志位true , 正常情况，程序停止

4.中断标志位true，异常情况，interruptedException，将会把中断状态清楚，并且将收到 interruptedException，中断标志位false，导致无线循环

5.在catch块里，需要二再次给中断标志位设置为true，2次调用停止程序才ok

public class InterruptDemo3 {

    public static void main(String[] args) throws InterruptedException {
        //实例方法interrupt()仅仅时设置线程的中断状态位为ture
        Thread t1 = new Thread(() -> {
            while (true){
                if(Thread.currentThread().isInterrupted()){
                    System.out.println(Thread.currentThread().getName()+"\t"+
                            Thread.currentThread().isInterrupted()+"标志位");
                        break;
                }
                //程序不会停下来，因为sleep方法抛出interruptException后，中断标志位被重置为false，标志位会被clear
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    //再次调用interrupt
                    Thread.currentThread().interrupt();
                    e.printStackTrace();
                }
                System.out.println("----hello interrupt Demo3");
            }
        }, "t1");
        t1.start();

        //暂停几秒钟线程
        TimeUnit.SECONDS.sleep(1);
        new Thread(()-> t1.interrupt(),"t2").start();
    }

}

总结： 中断只是一种协商机制，修改中断标志位仅此而已，不是立刻stop打断

3.静态方法Thread.interrupted(),谈谈你的理解

public static boolean interrupted()

静态方法，Thread.interrupted();****判断线程是否被中断并清楚当前中断状态。****这个方法做了两件事：1.返回当前线程的中断状态，测试当前线程是否已被中断2.将当前线程的中断状态清零并重新设为false，清楚线程的中断状态****此方法有点不好理解，如果连续两次调用此方法，则第二次调用返回false，因为连续调用两次的结果可能不一样

  public static void main(String[] args) {
        //测试当前线程是否被中断（检查中断标志），返回一个boolean
        //第二次调用时中断状态已经被清楚了，将返回一个false
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
        System.out.println("----1");
        Thread.currentThread().interrupt();//中断标志位设置为true
        System.out.println("----2");
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
        System.out.println(Thread.currentThread().getName()+"\t"+Thread.interrupted());
    }

main	false
main	false
----1
----2
main	true
main	false

源码：

3. LockSupport是什么

作用：用于创建锁和其他同步类的基本线程阻塞原语

park()	除非许可证可用，否则禁用当前线程以进行线程调度。	阻塞线程
unpark()	如果给定线程尚不可用，则为其提供许可。	解除被阻塞线程

4.线程等待唤醒机制

1. 3种让线程等待和唤醒的方法

使用 Object中的wait() 方法让线程等待，使用 Object中的notify 方法唤醒线程
使用JUC种的 Condition的await() 方法让线程等待，使用 signal方法唤醒线程
LockSupport类可用阻塞当前线程以及唤醒指定被阻塞的线程

1. Object中的wait()，notify（）方法等待唤醒线程

正常情况： wait会释放锁

    public static void main(String[] args) {
        Object objectLock = new Object();

        new Thread(()->{
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\t"+"---come in");
                try {
                    //wait 等待时会释放锁
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"---被唤醒");
            }
        },"t1").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"唤醒t1");
            }
        },"t2").start();
    }

异常情况1：wait方法和notify方法，两个都去掉同步代码块

使用这个两个方法必须获得锁

    public static void main(String[] args) {
        Object objectLock = new Object();

        new Thread(()->{
            //synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\t"+"---come in");
                try {
                    //wait 等待时会释放锁
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"---被唤醒");
           // }
        },"t1").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
          // synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"唤醒t1");
           // }
        },"t2").start();
    }

异常情况2：将notify 放在wait方法签名

程序无法执行，无法唤醒

    public static void main(String[] args) {
        Object objectLock = new Object();
        new Thread(()->{
            synchronized (objectLock){
                objectLock.notify();
                System.out.println(Thread.currentThread().getName()+"唤醒t1");
            }
        },"t2").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName()+"\t"+"---come in");
                try {
                    //wait 等待时会释放锁
                    objectLock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"\t"+"---被唤醒");
            }
        },"t1").start();
    }

总结： wait和notify方法必须要在代码块或者方法里面，且成对出现使用

先wait后notify才ok

2.Condition中的await 和 signal方法唤醒等待线程

正常情况：

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(()->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+"---come in");
                condition.await();
                System.out.println(Thread.currentThread().getName()+"\t"+"----被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(5);

        new Thread(()->{
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName()+"\t"+"唤醒t1");
            }finally {
                lock.unlock();
            }
        },"t2").start();
    }

异常情况：

若没有在lock、unlock对里面，就无法正确调用condition中线程等待和唤醒的方法。

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        new Thread(()->{
            //lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+"---come in");
                condition.await();
                System.out.println(Thread.currentThread().getName()+"\t"+"----被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                //lock.unlock();
            }
        },"t1").start();

        TimeUnit.SECONDS.sleep(5);

        new Thread(()->{
          //  lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName()+"\t"+"唤醒t1");
            }finally {
              //  lock.unlock();
            }
        },"t2").start();
    }

异常情况2：

先signal 后 await.

线程一直运行不停止

    public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(()->{
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName()+"\t"+"唤醒t1");
            }finally {
                lock.unlock();
            }
        },"t2").start();

        TimeUnit.SECONDS.sleep(5);


        new Thread(()->{
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+"---come in");
                condition.await();
                System.out.println(Thread.currentThread().getName()+"\t"+"----被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        },"t1").start();

    }

总结： Condition中的线程等待和唤醒方法，需要先获取锁

一定要先await后signal，不要反了

上述两个对象Object和Condition使用的限制条件：

线程先要获取并持有锁，必须在锁块（Synchronized）中才行
必须先等待后唤醒

3.LockSupport

调用LockSupport.park()时

permit 许可证默认没有不能放行，所以一开始调park()方法当前线程就会阻塞，直到别的线程给当前线程的发放permit，park方法才会被唤醒。

调用LockSupport.unpark(thread)时

调用unpark(thread)方法后，就会将thread线程的许可证permit发放，会自动唤醒park线程，即之前阻塞中的locksupport.park()方法会立刻返回。

代码

1.正常+无锁化要求

2.先等待后等待都可用

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "---come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + "----被唤醒");
        }, "t1");
        t1.start();
        //暂停几秒钟
        TimeUnit.SECONDS.sleep(5);
        new Thread(()->{
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName()+"\t"+"----被唤醒");
        },"t2").start();
    }

类似于高速公路的ETC，提前买好了通信票，直接通过即可

特点：

形象的理解

线程阻塞需要消耗凭证，这个凭证最多只有1个。

当调用park方法时

如果有凭证，则会直接消耗掉这个凭证然后正常退出；
如果无凭证，就必须阻塞等待凭证可用；

而unpark则相反，它会增加一个凭证，但凭证最多只能有一个，累加无效。

4.面试题

为什么可用突破wait/notify的原有调用顺序

因为unpark获得了一个凭证，之后在调用park方法，就可用名正言顺的凭证消费，故不会阻塞。

先发放了凭证后续可用畅通无阻。

为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程

凭证的数量最多为1，连续调用两次unpark 和调用一次unpark效果一样，只会增加一个凭证；

而调用两次park 却需要消费两个凭证，证不够，不能放行。