引言

LockSupport

线程中断机制

什么是中断机制?

一个线程不应该由其他线程来强制中断或停止,应该由线程自己去停止

Thread.stop,Thread.suspend,Thread.resume 均已被弃用

Java 提供了一种协作协商机制——中断,也称为中断标识协商机制

若为 true,表示别的线程请求被该线程中断,中断后代码由程序员实现
中断只是一种协商机制,Java 中没有给中断增加任何语法,中断过程完全需要程序员自己实现
若要中断一个线程,需要手动调用 interrupt 方法,该方法将线程对象的中断标识设成 true,之后编写代码不断检测当前线程的标志位

每个线程对象均有一个中断标志位,用于表示线程是否被中断,该标志位为 true 表示中断,为 false 表示未中断

通过调用线程对象 interrupt 方法将该线程的标志位设为 true,可以在别的线程中调用,也可以在自己的线程中调用

说说一下 java.lang.Thread 类下的三个方法的区别

如何中断一个线程?
如何停止一个线程?

线程中断机制

中断机制相关 API 三个方法的说明

public void interrupt()

实例方法
仅仅设置了线程状态中断状态为 true,发起一个协商,并不会立刻停止线程

如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。如果以前的条件都没有保存，则该线程的中断状态将被设置。中断一个不处于活动状态的线程不需要任何作用。抛出： SecurityException – 如果当前线程无法修改该线程

public static boolean interrupted()

静态方法
首次调用返回线程状态,第二次调用将线程状态置为 false,并返回 fasle

测试当前线程是否已经中断。线程的_中断状态_ 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。返回：如果当前线程已经中断，则返回 true；否则返回 false。

public boolean isInterrupted()

实例方法
判断当前线程是否被中断(通过检查中断标志位)

测试线程是否已经中断。线程的_中断状态_ 不受该方法的影响。线程中断被忽略，因为在中断时不处于活动状态的线程将由此返回 false 的方法反映出来。返回：如果该线程已经中断，则返回 true；否则返回 false。

经典面试题中的中断机制考点

如何停止,中断运行中的线程

通过一个 volatile 变量实现

    static volatile boolean isStop = false;
    private static void m1_volatile() {
        new Thread(() -> {
            while (true) {
                if (isStop) {
                    System.out.println(Thread.currentThread().getName() + "t isStop被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 -----hello volatile");
            }
        }, "t1").start();

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

运行上述 demo

通过 AtomicBoolean

原子布尔型,该变量的操作无需加锁

    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    private static void m2_atomicBoolean() {
        new Thread(() -> {
            while (true) {
                if (atomicBoolean.get()) {
                    System.out.println(Thread.currentThread().getName() + "t atomicBoolean被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 -----hello atomicBoolean");
            }
        }, "t1").start();

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

效果

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

        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread().getName() + "t isInterrupted()被修改为true，程序停止");
                    break;
                }
                System.out.println("t1 -----hello interrupt api");
            }
        }, "t1");
        t1.start();

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

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //t2向t1发出协商，将t1的中断标志位设为true希望t1停下来
        new Thread(() -> {
            t1.interrupt();
        }, "t2").start();
        //t1.interrupt(); //main线程中断

效果

API

核心思想:在需要中断的线程中不断监听中断状态,一旦发生中断,就执行相应的中断处理业务逻辑 stop 线程

实例方法

interrupt(),没有返回值
interrupted,没有返回值

源码分析(interrupt)

Just to set the interrupt flag(只是为了设置中断标志)

interrupt0()为 native 方法,交由 OS 进行调度
源码分析(isInterrupted)

当前线程的中断标志位为 true,是不是线程就立刻停止?

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

        System.out.println("t1线程默认的中断标识：" + t1.isInterrupted());//false

        //暂停毫秒
        try {
            TimeUnit.MILLISECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t1.interrupt();//true
        System.out.println("t1线程调用interrupt()后的的中断标识01：" + t1.isInterrupted());//true

        try {
            TimeUnit.MILLISECONDS.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1线程调用interrupt()后的的中断标识03：" + t1.isInterrupted());//????---false中断不活动的线程不会产生任何影响。
    }

运行结果

t1线程默认的中断标识：false 									//活跃的线程默认中断标志位为false
-----: 1
-----: 2
-----: 3
...
-----: 132
t1线程调用interrupt()后的的中断标识01：true  	//interrupt方法仅修改中断标志位
-----: 133
-----: 134
...
-----: 300
t1线程调用interrupt()后的的中断标识02：true 	//再次监听线程中断标志位
//对于一个不活跃的线程,调用interrupt方法不产生任何运行,可以理解为恢复中断标志位默认值
t1线程调用interrupt()后的的中断标识03：false	
//线程结束

案例二

正常启动,正常中断

public static void main(String[] args) {
    Thread t1 = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
                System.out.println(Thread.currentThread().getName() + "t " +
                                   "中断标志位：" + Thread.currentThread().isInterrupted() + " 程序停止");
                break;
            }

            System.out.println("-----hello InterruptDemo3");
        }
    }, "t1");
    t1.start();

    //暂停几秒钟线程
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    new Thread(() -> t1.interrupt(), "t2").start();
}

效果,中断之前一直执行

在调用 sleep()方法过程中被中断.重置中断标志位,抛出 InteruptedException 异常

此时中断标志位为 false,线程正常执行,where(true)…..

效果

解决方案,在 catch 块中,再次调用 interrupt 方法复位中断标志位

                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();//为什么要在异常处，再调用一次？？
                    e.printStackTrace();
                }

interupt()源码

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

demo

     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());

        Thread.interrupted();//静态方法

        Thread.currentThread().isInterrupted();//实例方法
    }

每次调用都指行两次操作

返回但前线程中断标志位
重置中断标志位(false)

两个方法的区别

底层private native boolean isInterrupted(boolean ClearInterrupted);方法会根据传入的ClearInterrupted 参数确定是否重置中断标志位

静态方法 interupted 传入的ClearInterrupted 为 true
实例方法 isInterupted 传入的ClearInterrupted 为 false

小结

public void interupt()是一个实例方法

用于通知目标线程中断,仅仅设置目标线程中断标志位为 true

public boolean isInterupted()也是一个实例方法

判断当前线程是否被中断,通过检查中断标志位,返回中断标志位

public static boolean interupted()是 Thread 类的一个静态方法

先获取当前线程的中断标志位并返回,之后将当前线程的中断标志位重置为初始值(false)
不管线程是否被中断,第二次调用总是得到 false

LockSupport

是什么?

park 方法与 unpark 方法

说明

LockSupport 用于创建锁和其它同步类的基本线程阻塞原语
park 方法的作用是阻塞线程 , unpark 方法是接触阻塞线程

线程等待唤醒机制

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

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

Object 类中 wait 和 notify 方法实现线程等待和唤醒

正常情况,均在同步监视器中执行 wait 与 notify 方法,先执行 wait 方法后执行 notify 方法

    private static void syncWaitNotify() {
        Object objectLock = new Object();

        new Thread(() -> {
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "t ----come in");
                try {
                    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() + "t ----发出通知");
            }
        }, "t2").start();
    }

效果

结果说明

t1 先执行,正常阻塞,
t2 后执行,发出通知,结束线程
t1 被唤醒,继续执行,结束线程

去除同步监视器 synchronized 的情况

效果

结果说明

抛出两次异常IllegalMonitorStateException,非法的监视器状态异常
带一次是调用 wait 方法,第二次是调用 notify 方法

结论

wait 方法与 notify 方法的执行必须在当前线程已获取锁的情况下

正常情况下,将 notify 先于 wait 执行

     private static void syncWaitNotify() {
        Object objectLock = new Object();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (objectLock) {
                System.out.println(Thread.currentThread().getName() + "t ----come in");
                try {
                    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() + "t ----发出通知");
            }
        }, "t2").start();
    }

效果

结果说明

t2 先执行 notify 唤醒线程,此时 t1 还没启动
t1 运行进入 wait,等待唤醒,t2 已经结束,t1 陷入无限等待

结论

Object 中的 wait 于 notify 方法的使用有以下两个限制

两个方法均必须获取锁之后才能调用
wait 方法必须先于 notify 方法调用

Condition 接口中的 await 后的 signal 方法实现线程的等待和唤醒

与 Object 类中的方法类似

await 对标 wait 方法
signal 对标 notify 方法

正常情况

    private static void lockAwaitSignal() {
        Lock 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();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "t ----发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

无锁情况,将 luck 与 unlock 方法注掉

signal 先于 await 方法调用的情况

    private static void lockAwaitSignal() {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            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();

        //暂停几秒钟线程
        //try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            lock.lock();
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "t ----发出通知");
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }

结论

与 synchronized 的类似,须在获取锁之后进行调用,先等待再唤醒

Object 类和 Condition 接口实现的限制

调用之前必须获取锁对象
先等待后唤醒

LockSupport 类中的 park 等待与 unpark 唤醒

该类与使用它的每个线程关联一个许可证（在Semaphore类的意义上）。如果许可证可用，将立即返回park ，并在此过程中消费; 否则可能会阻止。如果尚未提供许可，则致电unpark获得许可。（与Semaphores不同，许可证不会累积。最多只有一个。）可靠的使用需要使用volatile（或原子）变量来控制何时停放或取消停放。对于易失性变量访问保持对这些方法的调用的顺序，但不一定是非易失性变量访问。

LockSupport 类使用了一种名为 Permit(许可)的概念做到阻塞和唤醒线程功能,每一个线程都有一个许可(permit)与 Semaphore 不同,LockSupport 许可上限是 1
主要方法

通过 LockSupport 调用 park 方法的执行过程

permit 许可证默认没有,不能放行
所以一开始调用 park 方法但前线程就会阻塞,
直至别的线程调用 unpark 为当前线程发放 permit,park方法才会唤醒
unpark 与 park 类似均调用自 UNSafe 类中的 unpark 方法

基于 LockSupport 实现等待唤醒

        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "t ----come in" + System.currentTimeMillis());
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "t ----被唤醒" + System.currentTimeMillis());
        }, "t1");
        t1.start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            LockSupport.unpark(t1);
            System.out.println(Thread.currentThread().getName() + "t ----发出通知");
        }, "t2").start();