个人中心
gpt4 book ai didi

详解Java 线程中断

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 25 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章详解Java 线程中断由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、前言

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

?
1
2
3
4
5
6
new Thread( new Runnable(
  @Override
  public void run() {
   // todo sth...
  }
)).start();

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

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

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

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

2、为何 Thread.stop 被废弃

?
1
2
3
4
5
6
7
8
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 进入阻塞时，会释放锁.

3、线程中断的含义

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

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

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

3.1、初步了解

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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());
  }
}

输出结果:

?
1
2
3
4
5
6
7
8
9
10
11
start thread
Thread running...
Thread running...
......
interrupt thread
Thread running...
Thread running...
......
thread's status = true
Thread running...
......

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

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
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" );
  }
}

输出结果:

?
1
2
3
4
5
6
7
8
9
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、一般标志位法退出线程

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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" );
  }
}

输出结果:

?
1
2
3
4
5
6
7
8
9
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、线程中断退出

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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" );
  }
}

输出结果:

?
1
2
3
4
5
6
7
8
9
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、标志位 + 线程中断结合

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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" );
  }
}

输出结果:

?
1
2
3
4
5
6
start thread
Thread will sleep 10s ------------------------- running
interrupt thread
main exit
Interrupted... Todo other things then exit......
Thread exit

4、总结

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

5、附录

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

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

原文链接：https://juejin.cn/post/6930638409287335949 。

最后此篇关于详解Java 线程中断的文章就讲到这里了,如果你想了解更多关于详解Java 线程中断的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

25 4 0
文章推荐： Linux Apache Web服务器安全的8种安全设置技巧
文章推荐： SpringBoot之瘦身部署的详细步骤
文章推荐： Linux基础之正则表达式，用户、组管理命令介绍
文章推荐： java代码实现mysql分表操作(用户行为记录)
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com