【多线程：interrupt 方法详解】
01.介绍
程序中，有些线程的中断需要外部干预，比如线程中存在while(true)循环，或者存在一些阻塞操作，比如 sleep、wait、join等。
中断线程的方式，如果直接使用stop、suspend等方法，对程序来说是不太严谨的，这些方法类似于直接杀死线程，可能会造成数据问题。
interrupt方法的使用可以解决该问题，调用指定线程的该方法，表示向指定线程发起通知，可以执行中断线程的操作了，而具体什么时候执行，由线程自己决定，这种方式可以让程序处理更加严谨。
02.打断阻塞状态线程
打断 sleep，wait，join 的线程 这几个方法都会让线程进入阻塞状态 打断 sleep 的线程, 会清空打断状态，以 sleep 为例
例子
import lombok.extern.slf4j.Slf4j;
@Slf4j(topic = "c.Test11")
public class Test11 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
log.debug("sleep...");
try {
Thread.sleep(5000); // wait, join
} catch (InterruptedException e) {
e.printStackTrace();
}
},"t1");
t1.start();
Thread.sleep(2000);
log.debug("interrupt");
t1.interrupt();
log.debug("打断标记:{}", t1.isInterrupted());
}
}结果
解释
按理来说 当被打断后 ==t1.isInterrupted()==的结果应该是true 表明是被打断，但是现在为false，原因是当interrupt打断的是阻塞状态的线程时，会抛出异常 然后重置==t1.isInterrupted()==为false，所以结果为false
03.打断正常状态的线程
例子
import lombok.extern.slf4j.Slf4j;
@Slf4j(topic = "c.Test12")
public class Test12 {
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
while(true) {
boolean interrupted = Thread.currentThread().isInterrupted();
if(interrupted) {
log.debug("被打断了, 退出循环");
break;
}
}
}, "t1");
t1.start();
Thread.sleep(1000);
log.debug("interrupt");
t1.interrupt();
log.debug("打断标记:{}", t1.isInterrupted());
}
}结果
19:08:03.063 c.Test12 [main] - interrupt
19:08:03.066 c.Test12 [t1] - 被打断了, 退出循环
19:08:03.066 c.Test12 [main] - 打断标记:true
解释
打断正常线程时==t1.isInterrupted()==为true，但也仅仅是这样 并不会直接打断线程，要真正的打断线程 需要根据==t1.isInterrupted()==的值来具体决定，这样做的目的是 我们需要对之前线程的数据保存现场或者处理，如果直接中断 则不能达到上述目的。
03.两阶段终止模式
提出问题
如何在一个线程T1中 “体面”的终止线程T2？这里的“体面”指的是给T2一个料理后事的机会。
错误的解决思路
1.使用线程对象的stop()方法停止线程
这种思路是错误的 因为Thread.stop()方法在结束线程时，会直接终止线程，并且会立即释放这个线程所有的锁，而这些锁恰恰是用来维持对象一致性的。如果此时，写入线程写入的数据正写到一半，并强行终止，那么对象就会被写坏，同时由于锁已经释放，另外一个等待该锁的线程就会顺理成章的对到了这个不一致的对象。
2.使用System.exit(int)方法终止线程
这个方法会让整个程序都停止，而我们的目的仅仅是停止一个线程
正确的解决思路
用interrupt方法，当陷入阻塞时 中断线程抛出异常 可以处理后事，当中断正常状态线程时 可以根据中断标记 来处理后事
代码
@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
public static void main(String[] args) throws InterruptedException {
TwoPhaseTermination tpt = new TwoPhaseTermination();
tpt.start();
Thread.sleep(3500);
log.debug("停止监控");
tpt.stop();
}
}
@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
// 监控线程
private Thread monitorThread;
// 启动监控线程
public void start() {
monitorThread = new Thread(() -> {
while (true) {
// 是否被打断
if (monitorThread.isInterrupted()) {
log.debug("料理后事");
break;
}
try {
Thread.sleep(1000);
log.debug("执行监控记录");
} catch (InterruptedException e) {
e.printStackTrace();
monitorThread.interrupt(); // 33行
}
}
}, "monitor");
monitorThread.start();
}
// 停止监控线程
public void stop() {
monitorThread.interrupt();
}
}结果
20:09:31.683 c.TwoPhaseTermination [monitor] - 执行监控记录
20:09:32.687 c.TwoPhaseTermination [monitor] - 执行监控记录
20:09:33.688 c.TwoPhaseTermination [monitor] - 执行监控记录
20:09:34.181 c.TwoPhaseTermination [main] - 停止监控
20:09:34.182 c.TwoPhaseTermination [monitor] - 料理后事
java.lang.InterruptedException: sleep interruptedat java.lang.Thread.sleep(Native Method) at cn.itcast.test.TwoPhaseTermination.lambda$start$0(Test13.java:46) at java.lang.Thread.run(Thread.java:748)
解释
这个代码就是 main线程让monitor线程“体面”，对于本代码来说 在主线程睡眠3.5s后 打断monitor线程 又因为monitor线程每次循环都睡眠1s 所以大概率 中断的是sleep阶段 所以 进入异常处理，这里注意第33行 很关键我们知道 在抛出异常后 中断标志就会重置 所以我们这里再次进行了==monitorThread.interrupt();==此时中断标记就为true，如果我们这里不进行==monitorThread.interrupt();==处理 则循环不会结束。万一我们中断了正常线程 则==monitorThread.isInterrupted();==直接为true 中断线程
图片解释
04.Thread.interrupted()方法介绍
Thread.interrupted()与对象.interrupt()的区别是：Thread.interrupted()运行后会清空打断状态，而 对象.isInterrupted()则不会清空打断状态
例子
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.locks.LockSupport;
import static cn.itcast.n2.util.Sleeper.sleep;
@Slf4j(topic = "c.Test14")
public class Test14 {
private static void test2() {
Thread t1 = new Thread(() -> {
log.debug("park...");
LockSupport.park();
log.debug("打断状态：{}", Thread.interrupted());
log.debug("打断状态：{}", Thread.interrupted());
});
t1.start();
sleep(1);
t1.interrupt();
}
private static void test() throws InterruptedException {
Thread t1 = new Thread(() -> {
log.debug("park...");
LockSupport.park();
log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
}, "t1");
t1.start();
sleep(1);
t1.interrupt();
}
public static void main(String[] args) throws InterruptedException {
test();
// test2();
}
}结果：test()
20:56:29.413 c.Test14 [t1] - park...
20:56:30.404 c.Test14 [t1] - 打断状态：true
20:56:30.405 c.Test14 [t1] - 打断状态：true
结果：test2()
20:57:06.181 c.Test14 [Thread-0] - park...
20:57:07.180 c.Test14 [Thread-0] - 打断状态：true
20:57:07.181 c.Test14 [Thread-0] - 打断状态：false
补充：park和unpark是以线程为单位精确阻塞和唤醒线程的
