[Java] 线程中断（三）

最新推荐文章于 2022-10-16 07:11:31 发布
最新推荐文章于 2022-10-16 07:11:31 发布
阅读量497 收藏
点赞数
分类专栏： Java线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sunshinesir/article/details/8116151
版权

       前两篇文章分别说明了线程应该由它自己来处理中断和运行中的线程如何自己处理中断，本文主要描述阻塞中的线程如何自己处理中断。线程阻塞其实就是在执行过程中，为了某些条件或基于别的什么原因，自愿的或被迫的暂定一定的时间，然后条件满足后再继续执行。查阅一下线程类，发现使线程阻塞的方法就这么几个：最常用的是sleep，让线程休眠一定的时间，时间过后再继续执行；其次是wait，让线程在一定时间内等待，直到被通知或超时就继续执行；然后是join，官方解释是等待该线程的终止，其实可以用来协调线程间执行顺序的问题。或当一个线程执行完或超时后线程继续往下执行。

       现在已明白了线程的阻塞情况，线程在阻塞时，说明JVM没有运行它，这时调用线程的interrupt()方法，线程会有反应吗，如果有的话会是什么反应呢。按照常规的理解，线程当前都暂停执行了，对它调用中断操作，应该没有响应才对。但是稍微想一想，就觉得这种情况不合理。假设一个场景，一个线程已经持有了一部分资源，又为了某个资源不到位，进入了等待或阻塞，这个等待也许会比较漫长，这时突然环境发生了变化，我们已经不需要这个线程再继续运行了，我们需要其它的线程开始运行，现在就需要把这个线程中断掉，我们现在调用了线程中断方法。对于线程的响应，我们做一下假设，假设一：线程继续阻塞直到超时或获得了资源时，才被重新调度执行，发现自己被中断了，然后自己执行中断处理，线程结束掉。假设二：线程永不超时，但是环境已变，可能永远等不来想要的资源。这样线程一直阻塞，已持有的资源也无法释放，就造成了死锁。对于以上两种假设，在实际当中都不应该是合理的。合理的情况应该是，即使线程处于阻塞状态，也应该能够快速的响应中断操作，事实上就是这样的。

       线程阻塞时，对于我们来说就是停下来不在执行。但是JVM对线程的信息要掌握的多，它还是在监视着线程的情况，这时如果出现中断，仍能够快速得到响应。线程在阻塞时遇到中断，JVM的做法是，先设置线程的状态为中断，然后再阻塞语句处直接抛出一个InterruptedException异常，然后再清除刚才设置的中断状态。我们可以捕获这个异常，做一些清理工作，然后退出线程，线程已及它的资源被释放掉。

下面是简单的示例代码：

Thread t1 = new Thread(new Runnable(){
			public void run() {
				System.out.println("线程开始执行...");
				
				try {
					System.out.println("线程开始休眠4秒...");
					Thread.sleep(4000);
					System.out.println("线程结束休眠4秒...");
				} catch (InterruptedException e) {
					System.out.println("线程发生异常...");
					System.out.println("线程，state：" + Thread.currentThread().getState() + ", alive：" + Thread.currentThread().isAlive() + ", interrupt: " + Thread.currentThread().isInterrupted());
				}
				
				System.out.println("线程继续执行...");
			}});
		
		System.out.println("线程未启动，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		t1.start();
		System.out.println("线程已启动，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		System.out.println("主线程休眠1秒钟，开始");
		Thread.sleep(1000);
		System.out.println("主线程休眠1秒钟，结束");
		System.out.println("线程在休眠，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		t1.interrupt();
		System.out.println("线程被中断，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		System.out.println("主线程休眠5秒钟，开始");
		Thread.sleep(5000);
		System.out.println("主线程休眠5秒钟，结束");
		System.out.println("线程已结束，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());


下面是运行的结果：

线程未启动，state：NEW, alive：false, interrupt: false
线程已启动，state：RUNNABLE, alive：true, interrupt: false
主线程休眠1秒钟，开始
线程开始执行...
线程开始休眠4秒...
主线程休眠1秒钟，结束
线程在休眠，state：TIMED_WAITING, alive：true, interrupt: false
线程被中断，state：TIMED_WAITING, alive：true, interrupt: true
主线程休眠5秒钟，开始
线程发生异常...
线程，state：RUNNABLE, alive：true, interrupt: false
线程继续执行...
主线程休眠5秒钟，结束
线程已结束，state：TERMINATED, alive：false, interrupt: false

       线程还没启动时，它的状态是NEW，没有存活，没有中断。线程启动后，状态为RUNNABLE，存活，没有中断。主线程休眠一秒钟，为了让子线程进入四秒休眠。主线程结束休眠后，子线程还在休眠，这时线程的状态是TIMED_WAITING，存活，没有中断。然后调用中断，子线程状态为TIMED_WAITING，存活，但是已经中断了。主线程进入休眠，接着子线程里面发生了异常，我们捕获了异常，线程的状态又变为RUNNABLE，存活，中断被清除了，子线程继续运行。当主线程结束休眠时，子线程早已结束，所以状态为TERMINATED，已经不再存活，当然也不中断。

下面是一个简单示例：

Thread t1 = new Thread(new Runnable(){
			public void run() {
				System.out.println("线程开始执行...");
				
				try {
					System.out.println("线程开始等待4秒...");
					synchronized(Thread.currentThread()) {
						Thread.currentThread().wait(4000);
					}
					System.out.println("线程结束等待4秒...");
				} catch (InterruptedException e) {
					System.out.println("线程发生异常...");
					System.out.println("线程，state：" + Thread.currentThread().getState() + ", alive：" + Thread.currentThread().isAlive() + ", interrupt: " + Thread.currentThread().isInterrupted());
				}
				
				System.out.println("线程继续执行...");
			}});
		
		System.out.println("线程未启动，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		t1.start();
		System.out.println("线程已启动，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		System.out.println("主线程休眠1秒钟，开始");
		Thread.sleep(1000);
		System.out.println("主线程休眠1秒钟，结束");
		System.out.println("线程在休眠，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		t1.interrupt();
		System.out.println("线程被中断，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		System.out.println("主线程休眠5秒钟，开始");
		Thread.sleep(5000);
		System.out.println("主线程休眠5秒钟，结束");
		System.out.println("线程已结束，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());


下面是运行结果：

线程未启动，state：NEW, alive：false, interrupt: false
线程开始执行...
线程已启动，state：RUNNABLE, alive：true, interrupt: false
线程开始等待4秒...
主线程休眠1秒钟，开始
主线程休眠1秒钟，结束
线程在休眠，state：TIMED_WAITING, alive：true, interrupt: false
线程被中断，state：TIMED_WAITING, alive：true, interrupt: false
线程发生异常...
主线程休眠5秒钟，开始
线程，state：RUNNABLE, alive：true, interrupt: false
线程继续执行...
主线程休眠5秒钟，结束
线程已结束，state：TERMINATED, alive：false, interrupt: false

下面是一个示例：

 

Thread t1 = new Thread(new Runnable(){
			public void run() {
				System.out.println("线程开始执行...");
				
				Thread t = new Thread(new Runnable(){
					public void run() {
						System.out.println("join线程运行...");
						try {
							Thread.sleep(5000);
						} catch (InterruptedException e) {
						
						}
					}});
				
				try {
					System.out.println("线程开始join 4秒...");
					t.start();
					t.join(4000);
					System.out.println("线程结束join 4秒...");
				} catch (InterruptedException e) {
					System.out.println("线程发生异常...");
					System.out.println("线程，state：" + Thread.currentThread().getState() + ", alive：" + Thread.currentThread().isAlive() + ", interrupt: " + Thread.currentThread().isInterrupted());
				}
				
				System.out.println("线程继续执行...");
			}});
		
		System.out.println("线程未启动，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		t1.start();
		System.out.println("线程已启动，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		System.out.println("主线程休眠1秒钟，开始");
		Thread.sleep(1000);
		System.out.println("主线程休眠1秒钟，结束");
		System.out.println("线程在休眠，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		t1.interrupt();
		System.out.println("线程被中断，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());
		System.out.println("主线程休眠5秒钟，开始");
		Thread.sleep(5000);
		System.out.println("主线程休眠5秒钟，结束");
		System.out.println("线程已结束，state：" + t1.getState() + ", alive：" + t1.isAlive() + ", interrupt: " + t1.isInterrupted());


下面是运行结果：

线程未启动，state：NEW, alive：false, interrupt: false
线程已启动，state：RUNNABLE, alive：true, interrupt: false
主线程休眠1秒钟，开始
线程开始执行...
线程开始join 4秒...
join线程运行...
主线程休眠1秒钟，结束
线程在休眠，state：TIMED_WAITING, alive：true, interrupt: false
线程发生异常...
线程被中断，state：RUNNABLE, alive：true, interrupt: false
线程，state：RUNNABLE, alive：true, interrupt: false
主线程休眠5秒钟，开始
线程继续执行...
主线程休眠5秒钟，结束
线程已结束，state：TERMINATED, alive：false, interrupt: false

     上面三个示例其实基本一样，每次运行的结果，打印的先后顺序不完全一样。

如文章里有错误，敬请指出，共同讨论！

编程新说
关注
专栏目录
Java多线程学习 （三） Thread的wait()方法执行
想飞的鱼
05-12 4459
public class Depository { int capability = 5; private static LinkedList pool = new LinkedList(); public LinkedList getPool() { return pool; } public synchronized int getSize() { return pool.size(); } pub
Java-并发-Java线程中断与停止线程详解
12-22
  Java 中的线程中断是一种线程间的协作模式，通过设置线程的中断标志并不能直接终止该线程的执行，而是被中断的线程根据中断状态自行处理。即“线程中断”并不是字面意思——线程真的中断了，而是设置了中断标志...
Java Wait错误用法
wuxiaopengnihao1的博客
07-23 341
为什么会是这样的结果呢？按道理来说,应该是下面这个结果才对呀。它为什么会在1号线程等待的时候，2号线程运行了呢，它不应该是要等待1号线线程中的锁释放了才能运行的吗？又为什么会报两个错呢？那么带着问题我们来分析下这段代码。...
问题未解决 | this.wait()和Thread.currentThread().wait()有啥区别
你个无聊小demo的博客
10-16 426
问题未解决 | this.wait()和Thread.currentThread().wait()有啥区别
java中curr是什么意思,在Java中使用synchronized（Thread.currentThread（））{...}的目的是什么？...
weixin_42509548的博客
02-28 279
I faced the following code in our project:synchronized (Thread.currentThread()){//some code}I don't understand the reason to use synchronized on currentThread.Is there any difference betweensynchroni...
正确理解wait()和notify()方法
起风了的博客
04-08 239
对于初学者来说，下面这个例子是一个非常常见的错误。 /** * 线程A： 循环50次后等待并放弃锁，让线程B执行。 */ class ThreadA extends Thread{ //线程同步的公共数据区 Object oa=null; ThreadA(Object o){ this.oa=o; } //线程A执行逻辑 public void run(){
Java多线程中断机制三种方法及示例
08-28
"Java多线程中断机制三种方法及示例" Java多线程中断机制是Java编程语言中一个重要的概念，涉及到线程的生命周期和线程的协作机制。中断机制是一种协作机制，通过中断并不能直接终止另一个线程，而需要被中断的线程...
java线程阻塞中断与LockSupport使用介绍
09-05
Java线程阻塞中断是Java并发编程中的一个重要概念，它涉及到线程的生命周期管理以及协作。`Thread.interrupt()` 方法是用于向线程发送中断请求，而`LockSupport` 是Java 5引入的一个低级别的线程同步工具，提供了比`...
详解Java线程中断知识点
08-26
Java线程中断是多线程编程中一个关键的概念，它允许一个线程在运行时被其他线程“通知”停止其当前活动。线程中断不是立即终止线程，而是发送一个中断信号，由目标线程自己决定如何响应这个信号。在Java中，线程中断...
并发编程(一) synchronized用法
zsx18273117003的博客
12-05 175
背景：JDK13、IDEA2019.2.4、Gradle6.0.1 一、synchronized修饰整个类 package com.zsx.demo; import lombok.extern.log4j.Log4j2; import java.time.LocalDateTime; import java.util.concurrent.TimeUnit; @Log4j2 publi...
Java-线程Thread等待与唤醒
井底之蛙
03-29 5230
Java线程的等待与唤醒主要包括几个方法：（1）notify()：唤醒在此对象监视器上等待的单个线程。（2）notifyAll()：唤醒在此对象监视器上等待的所有线程。（3）wait()：让当前线程处于阻塞状态，同时释放它所持有的锁。（4）wait(long timeout)：让线程处于阻塞状态，直到其他线程调用此对象的notify()或者notifyAll()方法，或者超过指定的时间量，当前线程
理解线程的等待释放(wait/notify)
码农界的小学生
12-27 366
下面有个错误的例子 /**  *  线程A： 循环50次后等待并放弃锁，让线程B执行。  */ class ThreadA extends Thread{      //线程同步的公共数据区         Object oa=null;             ThreadA(Object o){         this.oa=o;     }     //线程A执行
Thread类的wait(),notify(),notifyAll()接口的使用方法实战后的理解
coding_1994的博客
02-19 678
java多线程在学习的时候感觉就那么几个类，几个方法，搞了一个生产者消费者例子就去参加校园招聘了。但真正用到后发现学的时候细节没有照顾到，有些问题也没有想过，所以书到用时方恨少。 既然生产者消费者这个例子是课堂上以及部分公司的招聘题目，那么就还是用它举个例子吧，例子不在于多么高大上，能帮助真正吸收就可以。 举个例子，如果你的Java程序中有两个线程——即生产者和消费者，那么生产者可以通知消费者...
wait()方法的注意点
NULL的博客
10-29 1万+
一、问题是什么？ 这个问题是我昨天测试wait()方法的时候偶然发现的，即： 一个线程在同步块或者同步方法中使用同步对象调用 wait() 方法的时候，会出现另一个线程在同步块或者同步方法中不使用 notify() 方法，被 wait() 的线程就能自动被唤醒的现象。当然这个需要分两种情况，这个下面会具体说到 我花了半个下午加一个晚上的时间，查了很多资料，问了一些人，才勉强搞懂为什么会出现这种情况...
Java多线程——synchronized使用详解
热门推荐
zhangqiluGrubby的博客
06-12 6万+
一 前言 Java多线程是面试必考的知识点，哈哈，说的有点太绝对了，题外话不说那么多了，今天我们就来了解一下Java多线程中的synchronized。 synchronized相信大家都看过或者用过，synchronized是Java中的关键字，synchronized可以保证方法或者代码块在运行时，同一时刻只有一个方法可以进入到临界区，同时它还可以保证共享变量的内存可见性，Java中每一个...
关于JAVA中Thread和synchronized参数的一点理解
寻码启示
03-13 346
什么时候要用Thread 在java开发过程中，有时候会对执行速度、效率有一定要求，这时候就可以借助线程（Thread）来帮助实现了。 Thread的创建和执行 Thread的创建和执行的方法比较多，可根据需要和习惯自由选择。 如简单的创建、执行： Runnable runnable = new Runnable(){ public void run(){ } }; new Thread(runnable).start(); new Thread() { @Override public void
Java多线程之currentThread()方法
Lucky_xiang
08-08 2万+
currentThread()方法 currentThread()方法返回正在被执行的线程的信息。 public class Run1{ public static void main(String[] args){ System.out.println(Thread.currentThread().getName()); } } 注意事项：main线...
Java线程中断机制深入解析
因此，我将基于Java线程中断机制的知识点进行详细阐述，以便满足您对于IT知识方面的需求。 Java线程中断机制是Java并发编程中的一个重要概念，它允许一个线程去中断另一个线程。在Java中，线程中断并不是直接中断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值