线程阻塞和线程中断
本专栏学习内容又是来自尚硅谷周阳老师的视频
有兴趣的小伙伴可以点击视频地址观看
中断机制
简介
Java线程中断机制是一种用于协作式线程终止的机制。它通过将一个特殊的中断标志设置为线程的状态来实现。当线程被中断时，它可以检查这个中断标志并采取相应的措施来停止线程的执行。
首先
一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止，自己决定自己的命运
其次
在Java中没有办法立刻停止一条线程，中断也只是一种协商机制，Java并没有给中断增加任何语法，中断的过程需要程序员自己实现。
三大中断方法说明
| 方法名 | 作用 |
|---|---|
| void interrupt() | 中断这个线程 |
| static boolean interrupted() | 测试当前线程是否中断。 该方法可以清除线程的中断状态 。 |
| boolean isInterrupted() | 测试这个线程是否被中断，true代表中断 |
线程中断实现
小黄认为线程中断是一种编程的思想，例如A线程需要中断，应该是A线程去监听某一个数据，当这个数据改变时，中断该线程
while(true) {
if (xxx) {
//线程中断
break;
}
}
线程中断应该是由被中断线程自己操作的，例如在餐厅中，服务员来提醒小明此地禁止吸烟，然后由小明将烟掐灭，而不是服务员上去直接把烟掐灭
通过volatile关键字
volatile 是 Java 中的一个关键字，用于修饰变量。当一个变量被声明为 volatile 时，表明这个变量是被多个线程共享的，并且在多线程环境下具有特殊的可见性和禁止重排序的特性。
public class VolatileDemo {
static volatile boolean flag = false;
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
while (true) {
if (flag) {
System.out.println(Thread.currentThread().getName() + "掐灭烟头");
break;
}
System.out.println(Thread.currentThread().getName() + "正在吸烟。。。");
}
},"t1").start();
TimeUnit.MILLISECONDS.sleep(20);
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 禁止吸烟!!");
flag = true;
},"t2").start();
}
}
从执行结果可以看出，t2线程发出指令后，t1线程中断了，至于多输出了一次是因为上一次循环还没有执行结束
使用AtomicBoolean
AtomicBoolean 是 Java 中 java.util.concurrent.atomic 包提供的一个原子布尔类型，用于在多线程环境中进行原子性的布尔操作。
使用原理跟volatile差不多，都是通过其他线程改变监听对象属性来中断线程
public class AtomicDemo {
static AtomicBoolean flag = new AtomicBoolean(false);
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
while (true) {
if (flag.get()) {
System.out.println(Thread.currentThread().getName() + "掐灭烟头");
break;
}
System.out.println(Thread.currentThread().getName() + "正在吸烟。。。");
}
},"t1").start();
TimeUnit.MILLISECONDS.sleep(20);
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 禁止吸烟!!");
flag.set(true);
},"t2").start();
}
}
使用Thread API
需要isInterrupted()和interrupt()配合使用
public class InterruptDemo {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while (true) {
if (Thread.currentThread().isInterrupted()) {
System.out.println(Thread.currentThread().getName() + "掐灭烟头");
break;
}
System.out.println(Thread.currentThread().getName() + "正在吸烟。。。");
}
}, "t1");
t1.start();
TimeUnit.MILLISECONDS.sleep(20);
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + " 禁止吸烟!!");
t1.interrupt();
},"t2").start();
}
}
源码分析
interrupt()
interrupt()调用了interrupt0()，而interrupt0()是本地方法，也就是由c++写的
特别需要注意的是interrupt0()旁边的注释Just to set the interrupt flag只是改变状态，并不是中断线程
isInterrupted()
isInterrupted()底层调用的也是一个本地方法，传了一个false进去
当参数为false时，isInterrupted(false)方法仅返回当前线程的中断状态，但不会清除中断状态。当参数为true时，isInterrupted(true)方法在返回中断状态之后会将中断状态重置为false，相当于清除了中断状态。
深度解析案例
先来看一下API文档，有两个特别需要注意的地方
- 如果线程正在阻塞状态，调用该线程的
interrupt()会将中断状态清楚，并且收到异常 - 中断不存在的线程没有任何效果
案例
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 30; i++) {
if (Thread.currentThread().isInterrupted()) {
System.out.println(Thread.currentThread().getName() + "：中断");
break;
}
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println("===interrupt=== : " + i);
}
}, "t1");
t1.start();
TimeUnit.MILLISECONDS.sleep(2000);
t1.interrupt();
}
可以从结果看出，在现场休眠时中断线程，会抛出异常，但是线程会继续运行，这是因为会清除中断状态
解决方案：在捕获异常时，再次中断线程
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 30; i++) {
if (Thread.currentThread().isInterrupted()) {
System.out.println(Thread.currentThread().getName() + "：中断");
break;
}
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
//重新中断线程
Thread.currentThread().interrupt();
e.printStackTrace();
}
System.out.println("===interrupt=== : " + i);
}
}, "t1");
t1.start();
TimeUnit.MILLISECONDS.sleep(2000);
t1.interrupt();
}
静态方法interrupted()
interrupted()会将线程中断，并且清除线程的中断状态
public static void main(String[] args) {
System.out.println(Thread.interrupted());//false
System.out.println(Thread.interrupted());//false
Thread.currentThread().interrupt();
System.out.println(Thread.interrupted());//true
System.out.println(Thread.interrupted());//false
}
可以看一下源码，跟isInterrupted()一样，调用的都是本地方法isInterrupted()，不过传参为true，方法在返回中断状态之后会将中断状态重置为false，相当于清除了中断状态。
LockSupport
简介
LockSupport 是 Java 并发包中的一个工具类，提供了线程阻塞和唤醒的能力，说到线程阻塞和唤醒就不得不提到两种已经学过的方式
synchronized配合wait()、notify()Lock配合await()、signal()
wait()、notify()实现阻塞和唤醒
执行以下代码，可以实现阻塞和唤醒，这里需要了解的是wait()会暂时释放锁，直到被唤醒之后重新排队获取锁
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
new Thread(() -> {
synchronized (object) {
try {
System.out.println(Thread.currentThread().getName() + "----come in");
object.wait();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"t1").start();
TimeUnit.MILLISECONDS.sleep(200);
new Thread(() -> {
synchronized (object) {
object.notify();
System.out.println(Thread.currentThread().getName() + "----发送通知");
}
},"t2").start();
}
//结果
t1----come in
t2----发送通知
t1----被唤醒
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() + "----come in");
condition.await();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}finally {
lock.unlock();
}
}, "t1").start();
TimeUnit.MILLISECONDS.sleep(200);
new Thread(() -> {
lock.lock();
try {
condition.signal();
System.out.println(Thread.currentThread().getName() + "----发送通知");
}finally {
lock.unlock();
}
}, "t2").start();
}
缺点
上述两种代码从功能上都可以实现线程的阻塞和唤醒，但是都有两个相同的缺点
必须要加锁
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
new Thread(() -> {
try {
System.out.println(Thread.currentThread().getName() + "----come in");
object.wait();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}, "t1").start();
TimeUnit.MILLISECONDS.sleep(200);
new Thread(() -> {
object.notify();
System.out.println(Thread.currentThread().getName() + "----发送通知");
}, "t2").start();
}
如果不加锁，程序会报错
必须先阻塞，在唤醒
public static void main(String[] args) throws InterruptedException {
Object object = new Object();
new Thread(() -> {
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (object) {
try {
System.out.println(Thread.currentThread().getName() + "----come in");
object.wait();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"t1").start();
new Thread(() -> {
synchronized (object) {
object.notify();
System.out.println(Thread.currentThread().getName() + "----发送通知");
}
},"t2").start();
}
如果先唤醒，程序会一直阻塞
LockSupport使用
先介绍一下主要的API，有点类似于上高速公路，进入高速时领取一个通行证，出高速归还通行证
| 方法 | 作用 |
|---|---|
| static void park() | 禁止当前线程进行线程调度，除非许可证可用。 |
| static void unpark(Thread thread) | 为给定的线程提供许可证（如果尚未提供）。 |
代码
从使用上就可以看出它没有加锁释放锁的过程
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "----come in");
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
}, "t1");
t1.start();
TimeUnit.MILLISECONDS.sleep(200);
new Thread(() -> {
LockSupport.unpark(t1);
System.out.println(Thread.currentThread().getName() + "----发送通知");
}, "t2").start();
}
优势
它可以先颁发通行证，当线程执行到需要通行证时，会直接通过，不再等待
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "----come in");
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
}, "t1");
t1.start();
new Thread(() -> {
LockSupport.unpark(t1);
System.out.println(Thread.currentThread().getName() + "----发送通知");
}, "t2").start();
}
//结果
t2----发送通知
t1----come in
t1----被唤醒
重点说明
对于一个线程来说，最多只能拥有一个通行证
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "----come in");
LockSupport.park();
LockSupport.park();
System.out.println(Thread.currentThread().getName() + "----被唤醒");
}, "t1");
t1.start();
new Thread(() -> {
LockSupport.unpark(t1);
LockSupport.unpark(t1);
System.out.println(Thread.currentThread().getName() + "----发送通知");
}, "t2").start();
}
执行上述代码，虽然调用了两次unpark()但是t1还是只拥有一个通行证，导致程序阻塞
