多线程JUC 第2季 中断线程（Interrupted，Interrput，IsInterput）

已于 2024-08-16 23:27:12 修改
阅读量466 收藏 5
点赞数 9
分类专栏： 高并发多线程 文章标签： java 开发语言
于 2024-03-03 07:57:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011066470/article/details/136426202
版权

一 中断线程

1.1 中断概念

1.在java中，没有提供一种立即停止一条线程。但却给了停止线程的协商机制-中断。

中断是一种协商机制。中断的过程完全需要程序员自己实现。也即，如果要中断一个线程，你需要手动调用该线程的interrupt()方法，该方法也仅仅是将线程对象中的中断标识设置成true；接着需要自己在方法中手动判断当前线程的标识位，如果为true，则中断线程。false标识未中断。

2.一个线程不应该由其他线程中断或者停止，而是有该线程自己自行停止，自己决定命运。

stop(),suspend,resume方法都已经废弃。

1.2 interrupt和isinterrupted和interrupted的作用

1.public void interrupt(): 实例方法，仅仅是设置线程中断状态为true,发起一个协商而不会立刻停止线程。

2.public static boolean interrupted；静态方法，判断当前线程是否中断并清除当前线程的中断状态。做两件事：

a)返回当前线程的中断状态，测试当前线程是否已经中断。

b)将当前线程的中断状态清零并重新设置为false，清除线程的中断状态。

3.public boolean isinterrupted():实例方法判断当前线程是不是中断，检测中断标志位。

1.3 interrupt的使用情况分析

当对一个线程，调用interrupt()时：

1.如果线程处于正常活动状态，那么会将该线程的中断标志设置为true，仅此而已。

被设置中断标志的线程将继续正常运行，不受影响。

interrupt（）并不能真正中断线程，需要被调用的线程自己进行配合才行。

2.如果线程A处于被阻塞状态(sleep,wait,join等状态)，在别的线程中调用线程A对象的interrupt方法，那么线程将立即退出被阻塞的状态，并抛出一个interruptedException异常。 

二 中断线程方式

2.1 方式1 通过volatile变量

package com.ljf.thread.interrupt;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @ClassName: Zhongduan2
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/03/02 17:43:01 
 * @Version: V1.0
 **/
public class Zhongduan2 {
    public static volatile boolean flag=false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    if(flag){
                   //     if(atomicBoolean.get()){
                        System.out.println("===================开始中断"+Thread.currentThread().getId());
                        break;
                    }
                    else{
                        System.out.println("循环中:"+Thread.currentThread().getId());
                    }
                }
            }
        });
        t1.start();
        //主线程先休眠2秒
        Thread.sleep(5000);
        new Thread(new Runnable() {
            @Override
            public void run() {
                flag=true;
                atomicBoolean.set(true);
            }
        }).start();
    }

}

2.2  方式2 通过atomicboolean 原子类

public static volatile boolean flag=false;
    static AtomicBoolean atomicBoolean = new AtomicBoolean(false);
    public static void main(String[] args) throws InterruptedException {
        Thread t1= new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                   // if(flag){
                        if(atomicBoolean.get()){
                        System.out.println("===================开始中断"+Thread.currentThread().getId());
                        break;
                    }
                    else{
                        System.out.println("循环中:"+Thread.currentThread().getId());
                    }
                }
            }
        });
        t1.start();
        //主线程先休眠2秒
        Thread.sleep(5000);
        new Thread(new Runnable() {
            @Override
            public void run() {
                flag=true;
                atomicBoolean.set(true);
            }
        }).start();
    }

2.3 方式3 通过interrupt+isinterrupted组合判断

package com.ljf.thread.interrupt;

/**
 * @ClassName: Zhongduan
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/03/02 17:34:59 
 * @Version: V1.0
 **/
public class Zhongduan {
    public static volatile boolean flag=false;
    public static void main(String[] args) throws InterruptedException {
       Thread t1= new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    if(Thread.currentThread().isInterrupted()){
                        System.out.println("===================开始中断"+Thread.currentThread().getId());
                        break;
                    }
                    else{
                        System.out.println("循环中:"+Thread.currentThread().getId());
                    }
                }
            }
        });
       t1.start();
        //主线程先休眠2秒
        Thread.sleep(5000);
        new Thread(new Runnable() {
            @Override
            public void run() {
                t1.interrupt();
            }
        }).start();
    }
}

三 中断线程方式的情况分析

3.1 场景1：Isinterrupted在jdk8和jdk17多次执行异同

3.1.1 在jdk8下

    public static void main(String[] args)
    {
        //实例方法interrupt()仅仅是设置线程的中断状态位设置为true，不会停止线程
        Thread t1 = new Thread(() -> {
            for (int i = 1; i <=300; i++)
            {
                System.out.println("-----: "+i);
            }
            System.out.println("t1线程调用interrupt()后的的中断标识02："+Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();

        System.out.println("t1线程默认的中断标识："+t1.isInterrupted());//false

        //暂停毫秒
        try { TimeUnit.MILLISECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
        t1.interrupt();//true
        System.out.println("t1线程调用interrupt()后的的中断标识01："+t1.isInterrupted());//true

        try { TimeUnit.MILLISECONDS.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("t1线程调用interrupt()后的的中断标识03："+t1.isInterrupted());//---false中断不活动的线程不会产生任何影响。
    }

线程t1执行300次后，已经不存在，2秒后查看t1线程的状态为false。

3.1.2 在jdk17下

3.1.3 原因

3.2 场景2 interrupt+阻塞（wait，sleep，join）则抛出异常

3.2.1 interrupt+sleep抛出异常

1.代码

public class InterruptDemo3
{
    public static void main(String[] args)
    {
        Thread t1 = new Thread(() -> {
            while (true)
            {
                if(Thread.currentThread().isInterrupted())
                {
                    System.out.println(Thread.currentThread().getName()+"\t " +
                            "中断标志位："+Thread.currentThread().isInterrupted()+" 程序停止");
                    break;
                }

                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("-----hello InterruptDemo3");
            }
        }, "t1");
        t1.start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> t1.interrupt(),"t2").start();
    }
}

2.问题：报异常，程序没有停止，抛出中断异常

3.分析原因

1)中断标志位，默认为false，t2调用t1.interrupt();.中断标志位为true；

2)正常情况请下，中断标志位为true，程序应该停止。但是t2调用t1.interrupt()方法且t1此时调用sleep方法处于阻塞状态，则触发 【将中断状态清除（中断标志变为false），并收到interruptedException，中断标志为false，导致无限循环。

4.解决办法：在catch快中，再次设置中断标志位为true，2次调用停止程序才ok。

完整代码

package com.jurf.ms.fegin.juc;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName: InterruptDemo3
 * @Description: TODO
 * @Author: admin
 * @Date: 2024/08/16 14:52:22 
 * @Version: V1.0
 **/
public class InterruptDemo3 {
    public static void main(String[] args)
    {
        Thread t1 = new Thread(() -> {
            while (true)
            {
                if(Thread.currentThread().isInterrupted())
                {
                    System.out.println(Thread.currentThread().getName()+"\t " +
                            "中断标志位："+Thread.currentThread().isInterrupted()+" 程序停止");
                    break;
                }

                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();//为什么要在异常处，再调用一次？？
                    e.printStackTrace();
                }

                System.out.println("-----hello InterruptDemo3");
            }
        }, "t1");
        t1.start();

        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> t1.interrupt(),"t2").start();
    }
}

3.2.2  结论

1.如果线程A处于被阻塞状态(调用wait()，wait(long), wait(long,int)的objet类，或者join，join(long),join(long,int),或者sleep(long）,sleep(long,int),这个类的方法)，同时在别的线程中调用线程A对象的interrupt方法，那么线程将立即退出被阻塞的状态，中断状态将被清除（中断状态变为false），并抛出一个interruptedException异常。

2.这里sleep方法抛出InterruptedException后，中断标志也被清空设置为false，我们需要在catch块中再次调用interrupt()方法，将中断标志设置为true，否则导致无限循环。

3.3 案例3 关闭线程

https://blog.51cto.com/u_13316945/5832262

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

Future future = fixedThreadPool.submit(new Runnable() { @Override public void run() { 
new Runnable() {
            @Override
            public void run() {
                /*
                 * 确保线程不断执行不断刷新界面
                 */
                while (true&&(!Thread.currentThread().isInterrupted())) {
                    try {

                        Log.i("tag","线程运行中"+Thread.currentThread().getId());

                        // 每执行一次暂停40毫秒
                        //当sleep方法抛出InterruptedException  中断状态也会被清掉
                        Thread.sleep(40);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        //如果抛出异常则再次设置中断请求
                        Thread.currentThread().interrupt();
                    }
                }
            }
        }
);
//触发条件设置中断
future.cancel(true);

健康平安的活着
关注
专栏目录
JUC学习 - 中断线程的几种方式
TyuIn的博客
11-25 148
一、中断线程的几种方式 1、通过一个变量控制线程中断 public class ThreadInterruptedDemo { public volatile static boolean exit = false; public static class T extends Thread { @Override public void run() { while (true) { //循环处理
【Java多线程】JUC之并发容器—深入剖析并发队列LinkedTransferQueue(八)
墩墩分墩
03-09 2874
- **LinkedTransferQueue**： 一个由`链表`结构组成的`无界阻塞队列`，相对于其它队列该类实现了**TransferQueue接口**，多了`transfer()和tryTransfer()`方法。 - **若当前存在一个正在等待transfer元素的消费者线程，就直接将元素 “交给” 等待者；否则会put当前元素到队尾，并进入阻塞状态，等待消费者线程transfer该元素。**
如何中断当前线程
业精于勤-行成于思
11-10 819
如何中断当前线程中断当前线程有两种方式。第一种方式是通过调用线程的stop()方法，第二种方式通过调用interrupt()方法。 由于第一种方式是不安全的，所以本篇文章不做讨论，主要分享一下如何使用interrupt()方法来中断线程。采用interrupt中止线程Thread类中提供了三个中断线程的方法
线程之interrupt
一切皆有可能！
04-20 1237
interrupt概念   interrupt翻译成中文为“打断”的意思，但实际上，interrupt()方法并非将一个线程打中断的意思。查看Thread.interrupt()方法的源码： public void interrupt() { if (this != Thread.currentThread()) checkAccess(); synchronized (blockerLock) { Interruptible
线程中断——interrupt()
如不來的博客
10-09 222
1、interrupt()说明：根据api的说明，在线程处于中断状态时调用大部分的阻塞方法可能会抛异常 Interrupts this thread. Unless the current thread is interrupting itself, which is always permitted, the checkAccess method of this thread is inv...
【JUC（三）】中断与等待唤醒
种花途
07-02 195
和的区别通过上面的例子可以了解到：在Java中没有办法立即停止一条线程（处于阻塞状态除外），然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的——。中断只是一种协作协商机制，Java没有给中断增加任何语法，中断的过程完全需要程序员自己实现。比如调用了的方法。只能在 run 方法中使用与方法的返回值确定是否中断，然后自行编写中断逻辑。
java sleep方法_一文搞懂 Java 线程中断！
weixin_39645165的博客
12-02 831
在之前的一文《如何”优雅”地终止一个线程》详细说明了 stop 终止线程的坏处及如何优雅地终止线程，那么还有别的可以终止线程的方法吗？答案是肯定的，它就是我们今天要分享的——线程中断。下面的这断代码大家应该再熟悉不过了，线程休眠需要捕获或者抛出线程中断异常，也就是你在睡觉的时候突然有个人冲进来把你吵醒了。try { Thread.sleep(3000); } catch (Interrupted...
Java多线程与JUC
meiziziLOLOLO的博客
07-23 352
前言:多线程相关概念理解 大家应该都听过多线程这个概念，那到底是什么呢？下面辨析一些多线程里的概念，让大家对多线程理解更深一点，我也算是整理我的知识。 1.并发与并行 并发：两个或多个事件在用一个时间段内发生 并行：两个或多个事件在同一时刻发生（同时发生） 在我们的计算机中，如果你的CPU是多核的，这个核的数量就是处理任务的线程的数量，比如你是双核的，那你的计算机便能并行处理两个任务。如果你只有单核，但又有多个任务或者双核有两个以上的任务，这时候怎么办呢？这时候就是并发处理任务了。 并发处理
【Java多线程】JUC之并发工具-CyclicBarrier(同步循环栅栏)源码解析
墩墩分墩
03-24 6677
CyclicBarrier 基于 Condition 来实现的 - 在CyclicBarrier类的内部有一个计数器，每个线程在到达屏障点的时候都会调用await方法将自己阻塞，此时计数器会减1，当计数器减为0的时候所有因调用await方法而被阻塞的线程将被唤醒。这就是实现一组线程相互等待的原理，下面我们先看看CyclicBarrier有哪些成员变量。
【高并发】JUC中等待多线程完成的工具类CountDownLatch
九师兄
11-27 414
添加链接描述假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要统计解析总耗时。分析一下：解析每个sheet耗时可能不一样，总耗时就是最长耗时的那个操作。//休眠时间（秒） int sleepSeconds;System . out . println(startTime + "," + ct . getName() + ",开始处理!");try {
java sleep方法_Java 线程中断？看这篇就够了
weixin_39596739的博客
11-25 456
Java 程序中有不止一条执行线程，只有当所有的线程都运行结束的时候，这个 Java 程序才算运行结束。官方的话给你描述一下：当所有的非守护线程运行结束时，或者其中一个线程调用了 System.exit() 方法时，这个 Java 程序才能运行结束。线程中断即线程运行过程中被其他线程给打断了，它与 stop 最大的区别是：stop 是由系统强制终止线程，而线程中断则是给目标线程发送一个中断信号，如...
JUC学习：interrupt线程中断机制
qq_45266399的博客
10-20 185
主要介绍了interrupt()、interrupted()、isInterrupted()方法的概念与使用方法。
关于对 JUC 的 Interrupt 和 Interrupted 方法的一些理解
最新发布
weixin_59736343的博客
02-01 1882
在讲到中断方法之前，我们先谈谈什么是线程中断。在Java并发编程中，线程中断是一种协作机制，允许一个线程向另一个线程发出停止正在进行的操作的请求通知。这种通知是通过设置所谓的“中断状态”来实现的。但重要的是，线程中断不是强迫线程停止，而是给线程一个机会来优雅地结束它的执行。这个“机会”实际上是在告诉线程：“你可以继续进行，但有一个请求建议你在下一个合适的时刻停下来。”线程可以检查这个请求（即中断状态），然后决定是否以及何时响应。
理解Java线程的中断
dawuafang
06-18 151
一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果. 所以你看到Thread.suspend, Thread.stop等方法都被Deprecated了. 那么不能直接把一个线程搞挂掉, 但有时候又有必要让一个线程死掉, 或者让它结束某种等待的状态 该怎么办呢? 优雅的方法就是, 给那个线程一个中断信号, 让它自己决定该怎么办. 比如说, 在某个子线程中为...
线程-interrupt方法详解
白蝶的博客
07-15 2610
会让此线程产生一个InterruptedException异常，结束线程的运行。但如果该异常被线程捕获住，该线程依然可以自行决定后续处理（终止运行，继续运行，做一些善后工作等等），而且这个打断阻塞中的线程是会重置标状态为。这里不建议是使用stop方法，使用stop方法虽然可以强行终止正在运行或挂起的线程，但使用stop方法是很危险的。，线程会不时地检测这个中断标示位，以判断线程是否应该被中断（中断状态是否为true）我们如何在一个线程中暂停另一个线程的运行？...
终止线程的 4 种方式（interrupt）
逆水行舟
03-06 1148
正常运行结束 程序运行结束，线程自动结束。 使用标志位 一般 run() 方法执行完，线程就会正常结束，然而，常常有些线程是伺服线程。它们需要长时间的运行，只有在外部某些条件满足的情况下，才能关闭这些线程。使用一个变量来控制循环，例如：最直接的方法就是设一个 boolean 类型的标志，并通过设置这个标志为 true 或 false 来控制 while 循环是否退出，代码示例： public cl...
Juc22_什么是中断、interrupt、isInterrupted、interrupted方法源码解析、如何使用中断标识停止线程
所得皆惊喜
07-02 2342
文章目录①. 什么是中断②. 源码解读(中断的相关API)③. 如何使用中断标识停止线程 ①. 什么是中断 ①. 一个线程不应该由其他线程来强制中断或停止,而是应该由线程自己自行停止,所以,Thread.stop、Thread.suspend、Thread. resume都已经被废弃了 ②. 在Java中没有办法立即停止一条线程,然而停止线程却显得尤为重要,如取消一个耗时操作。因此,Java提供了一种用于停止线程的机制 — 中断 ③. 中断只是一种协作机制,Java没有给中断增加任何语法,中断的
问七：如何中断一个线程？
向代码提问
05-01 743
已经被抛弃的方法： 通过调用stop() 通过调用suspend()和resume()方法 废弃原因（再写具体一点）： 太过暴力，可能会导致一些清理工作不会完成 调用后会直接释放锁，可能会导致数据不同步的问题https://www.jianshu.com/p/e0ff2e420ab6 目前使用的方法： 调用interrupt()，通知线程应该中断 1.如果线程处于阻塞状...
线程中断机制,使用中断标识停止线程的的3种方法（附代码示例）
枫陵的博客
04-26 1612
1. 什么是中断？ 1. 一个线程不应该由其他线程来强制中断或停止，而是应该由线程自己自行停止。所以，Thread stop, Thread. suspend, Thread.resume都已经被废弃了。 2. 在Java中没有办法立即停止一条线程，然而停止线程却显得尤为重要，如取消一个耗时操作。因此，Java提供了一种用于停止线程的机制————中断。 3. 中断只是一种协作机制（并不能立刻stop一个线程），Java没有给中断增加任何语法，中断的过程完...
Java并发编程面试精华：JUC面试题与多线程解析
JUC是Java并发编程的核心库，提供了高级并发工具，如线程池、同步器、锁等，以提高多线程环境下的程序性能和可维护性。JUC库自Java 5引入，极大地简化了并发编程。 ### 线程的六种状态 1. **新建**（New）：线程被...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值