详解Java 线程中断

更新时间：2021年02月19日 11:21:50 作者：小小青叶

这篇文章主要介绍了Java 线程中断的相关资料，帮助大家更好的理解和使用Java，感兴趣的朋友可以了解下

一、前言

大家肯定都使用过 Java 线程开发（Thread / Runnable），启动一个线程的做法通常是：

new Thread(new Runnable(
 @Override
 public void run() {
  // todo sth...
 }
)).start();

然而线程退出，大家是如何做的呢？一般做法可能不外乎以下两种：

设置一个标志位：true / false 来退出；
强制退出：thread.stop；（我相信，现在应该没人会使用这种方式了，因为JDK也很早就废弃了该方法）

可能还会有人提出，我可以用中断来退出线程！我只能说：Too Young Too Simple！中断并不会使得线程结束而退出，中断（interrupt）只是唤醒被阻塞的线程而已。

本篇，我们就来好好的聊聊：线程中断，以及如何正确的使用线程中断，和正确的线程退出。

二、为何 Thread.stop 被废弃

This method is inherently unsafe. Stopping a thread with Thread.stop causes it to unlock all of the monitors that it 
has locked (as a natural consequence of the unchecked ThreadDeath exception propagating up the stack). If any of the 
objects previously protected by these monitors were in an inconsistent state, the damaged objects become visible to 
other threads, potentially resulting in arbitrary behavior. Many uses of stop should be replaced by code that simply 
modifies some variable to indicate that the target thread should stop running. The target thread should check this 
variable regularly, and return from its run method in an orderly fashion if the variable indicates that it is to stop 
running. If the target thread waits for long periods (on a condition variable, for example), the interrupt method 
should be used to interrupt the wait.

以上是官方 JDK 中的源码注释说明，其含义如下：

**Thread.stop 方法天生就不安全。**使用该方法来停止线程，将会导致其它因为监视器锁『监视器我们在 synchronized 中就讲过，是 Java 的内置锁』而被锁住的线程全部都解锁！（本质的后果是：没有检查的 ThreadDeath 异常会在栈中传播，因而使得监视器锁解锁）。如果任何一个被监视器锁给锁住的对象处于一个不一致的状态，那么其被解锁后将会被其它线程可见，潜在的结果是产生任何后果。**我们应该使用一个变量来代替使用 stop 方法，告诉目标线程退出『这里就是我们开头所说的第一种方法，设置一个标志位』。**目标线程应该周期性的检查这个变量，并根据这个变量来正确的退出 run 方法。如果目标线程处于阻塞/休眠状态（如：使用 wait、sleep、yield 方法后，线程让出了 CPU 使用权，进而阻塞/休眠），此时，该标志位变量将不会起作用，那么，应该使用 interrupt 方法来中断目标线程的阻塞/休眠状态，将其唤醒！

对于 ThreadDeath 对象，官方还有补充：

线程可以在几乎任何地方抛出 ThreadDeath 异常。由于这一点，所有的同步方法和（代码）块将必须被考虑得事无巨细。
线程在清理第一个 ThreadDeath 异常的时候（在 catch 或 finally 语句中），可能会抛出第二个。清理工作将不得不重复直到到其成功。保障这一点的代码将会很复杂。

所以，我们也别想着去 try-catch ThreadDeath Exception！

同样，被废弃的还有 Thread.resume 和 Thread.suspend。这俩方法有造成死锁的危险：

使用suspend时，并不会释放锁；
如果存在某种情况要先获取该锁，再进行resume，那么就造成死锁了；

取代这两方法的正确方式是：Object.wait 和 Object.notify ：

因为 Object.wait 进入阻塞时，会释放锁。

三、线程中断的含义

Thread 中有三个与中断相关的方法：

成员方法 interrupt()：设置线程中断标志为 true ；
成员方法 isInterrupted()：获取线程的中断状态，默认为 false，调用 interrupt() 后，该方法返回 true；
静态方法 Thread.interrupted()：获取线程的中断状态，并且清除中断状态（设置为 false）；

注：如果线程中断后，连续两次调用 Thread.interrupted()，第一次是 true & 清除状态，第二次结果是 false。

3.1、初步了解

我们先来通过一个例子来初步了解 thread.interrupt ：

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (true) {
   System.out.println("Thread running...");
  }
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();

  Thread.sleep(50);
  System.out.println("interrupt thread");
  thread.interrupt();

  Thread.sleep(50);
  System.out.println("thread's status = " + thread.isInterrupted());
 }
}

输出结果：

start thread
Thread running...
Thread running...
......
interrupt thread
Thread running...
Thread running...
......
thread's status = true
Thread running...
......

我们可以看到，即便我们调用了 thread.interrupt 方法，线程也并没有退出，仍旧继续运行。因此，这个例子证明了一点：我们并不能通过"我们所认为的"中断来试图"结束"正在运行的线程。

3.2、中断即唤醒阻塞/休眠的线程

同样，我们再来看一个例子：

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (true) {
   System.out.println("Thread will sleep 10s ------------------------- running");
   long timestamp = System.currentTimeMillis();
   try {
    Thread.sleep(10000);
   } catch (InterruptedException e) {
    System.out.println("thread interrupted...");
   }

   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(3000);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

输出结果：

start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
thread interrupted...
Thread run, total sleep = 3002(ms)
Thread will sleep 10s ------------------------- running
Thread run, total sleep = 10002(ms)
Thread will sleep 10s ------------------------- running

我们可以看到，线程启动后，进入睡眠（10s），3秒后被中断唤醒，执行完一个 while 后再次进入第二次睡眠（10s），然后周而复始。

3.3、一般标志位法退出线程

public class InterruptDemo implements Runnable {
 private static final AtomicBoolean running = new AtomicBoolean(true);

 @Override
 public void run() {
  while (running.get()) {
   long timestamp = System.currentTimeMillis();
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(100);
  System.out.println("interrupt thread");
  thread.interrupt();
  running.set(false);
  System.out.println("main exit");
 }
}

输出结果：

start thread
.......
Thread run, total sleep = 0(ms)
interrupt thread
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
main exit
Thread exit

我们通过使用一个 AtomicBoolean 变量来当作标志位，使得我们的线程能正常退出。我们也可以判断线程是否被中断而选择性的退出。

3.4、线程中断退出

public class InterruptDemo implements Runnable {
 @Override
 public void run() {
  while (!Thread.currentThread().isInterrupted()) {
   long timestamp = System.currentTimeMillis();
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(100);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

输出结果：

start thread
.......
Thread run, total sleep = 0(ms)
interrupt thread
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
Thread run, total sleep = 0(ms)
main exit
Thread exit

3.5、标志位 + 线程中断结合

public class InterruptDemo implements Runnable {
 private static final AtomicBoolean running = new AtomicBoolean(true);

 @Override
 public void run() {
  while (running.get()) {
   System.out.println("Thread will sleep 10s ------------------------- running");
   long timestamp = System.currentTimeMillis();
   try {
    Thread.sleep(10000);
   } catch (InterruptedException e) {
    System.out.println("Interrupted... Todo other things then exit......");
    running.set(false);
    continue;
   }
   timestamp = System.currentTimeMillis() - timestamp;
   System.out.println("Thread run, total sleep = " + timestamp + "(ms)");
  }
  System.out.println("Thread exit");
 }

 public static void main(String[] args) throws InterruptedException {
  Thread thread = new Thread(new InterruptDemo(), "InterruptDemo");

  System.out.println("start thread");
  thread.start();
  Thread.sleep(3000);
  System.out.println("interrupt thread");
  thread.interrupt();
  System.out.println("main exit");
 }
}

输出结果：

start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
Interrupted... Todo other things then exit......
Thread exit

四、总结

本文我们分析了线程的中断，并让大家了解了中断的含义：只是告诉该线程，你被『中断』了，至于你想干嘛，还是由你自己来决定。同时，我们也简单分析了几个废弃的方法的原因。希望大家学习了本文之后，能正确且合理的设计，线程如何安全的退出。

五、附录

Object.wait：阻塞当前线程，释放持有的锁；
Object.notify：唤醒当前对象上被阻塞的线程，使其进入就绪状态；
Object.notifyAll：唤醒所有线程；
Thread.sleep：指定当前线程休眠一定时间，让出CPU，但不会释放同步资源锁；
Thread.yield：让出CPU使用权，让自己和其它线程来争夺使用CPU的机会，因此，使用此方法后，并不能保证该线程又再次拿到CPU而恢复运行（使用此方法后，优先级高的线程拿到CPU的概率较大，但优先级低的线程也有概率拿到CPU而执行），同理不会释放同步资源锁；

以上就是详解Java 线程中断的详细内容，更多关于Java 线程中断的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

Java的基础语法学习笔记
这里为大家整理了Java的基础语法学习笔记,包括关键词、运算符与基本的流程控制语句写法等,需要的朋友可以参考下
2016-05-05
springcloud集成skywalking实现全链路追踪
在微服务治理中,springcloud也是技术选型中的一个成熟的解决方案,而且相对dubbo来说,springcloud涉及到的微服务组件更多,调用链路可能更复杂,本文将详细介绍下如何在springcloud中集成skywalking,需要的朋友可以参考下
2024-01-01
java判断字符串是否为数字的方法小结
这篇文章主要介绍了java判断字符串是否为数字的方法,分别讲述了使用Java自带函数、正则表达式及ascii码三种方法进行字符串判断的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
2015-11-11
详解IDEA2020新建spring项目和c3p0连接池的创建和使用
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，本文就使用Spring实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2021-08-08
128进制加密数据示例分享
这篇文章主要介绍了128进制加密数据示例，这里使用JAVA实现,需要的朋友可以参考下
2014-03-03
学习Java之File文件操作方法
这篇文章我们主要学习如何实现IO流的具体操作,但很多时候,IO流都会操作一个文件,所以我们需要先学习在Java中如何操作文件,包括文件及文件夹的创建、遍历、删除等,有了文件操作的基础,我们才能更好地操作IO流,文中有详细的代码示例,需要的朋友可以参考下
2023-09-09
详解利用Spring加载Properties配置文件
本篇文章主要介绍了详解利用Spring加载Properties配置文件，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-04-04
JAVA中值类型和引用类型的区别
在java开发中经常会遇到值类型和引用类型知识，但是有很多朋友不清楚java中值类型和引用类型的区别，今天小编通过本文给大家介绍下
2017-02-02
myatisplus的saveOrUpdate的提交总是update问题
这篇文章主要介绍了myatisplus的saveOrUpdate的提交总是update问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-11-11
如何在java中使用SFTP协议安全的传输文件
这篇文章主要介绍了如何在java中使用SFTP协议安全的传输文件，帮助大家更好的理解和使用JSch，感兴趣的朋友可以了解下
2020-10-10