java多线程编程：你真的了解线程中断吗？

java · 浏览次数 : 5

小编点评

本文主要讨论了Java中的Thread类及其中断方法。首先，文章解释了interrupt方法的作用和原理，即改变线程的中断状态。接着，通过几个demo展示了如何使用这些方法来检查和中断线程。最后，文章总结了这些方法的使用注意事项。 1. **interrupt方法**： - 中断方法的目的是改变线程的中断状态。 - 当线程处于sleep或wait等阻塞方法时，调用interrupt方法不会立即中断线程。 - 如果线程内部已经处理了中断异常，那么调用interrupt方法也不会产生效果。 2. **isInterrupted和interrupted静态方法**： - isInterrupted方法是Thread类的实例方法，用于检查当前线程的中断状态。 - interrupted静态方法是Thread类的静态方法，也用于检查线程的中断状态。 - 这两个方法都会重置中断状态为false，除非在检查之后又调用了相应的中断方法。 3. **中断异常的情况**： - 当线程在sleep或wait等阻塞方法中遇到中断时，会抛出InterruptedException异常。 - 中断异常会使线程从阻塞状态恢复，但不会中断锁阻塞。 - 可以使用Thread.interrupted方法来检查中断状态，避免因多次调用而产生的不一致性。 总的来说，了解线程的中断机制对于编写高效的并发程序至关重要。在实际应用中，应根据不同的阻塞方式选择合适的中断处理策略。

正文

java.lang.Thread类有一个 interrupt 方法，该方法直接对线程调用。当被interrupt的线程正在sleep或wait时，会抛出 InterruptedException 异常。事实上， interrupt 方法只是改变目标线程的中断状态（interrupt status），而那些会抛出InterruptedException 异常的方法，如wait、sleep、join等，都是在方法内部不断地检查中断状态的值，如果发现中断，则抛出InterruptedException异常。

interrupt方法

Thread实例方法：必须由其它线程获取被调用线程的实例后，进行调用。实际上，只是改变了被调用线程的内部中断状态；

Thread.interrupted方法

Thread类方法：必须在当前执行线程内调用，该方法返回当前线程的内部中断状态，然后清除中断状态（置为false） ；

isInterrupted方法

Thread实例方法：用来检查指定线程的中断状态。当线程为中断状态时，会返回true；否则返回false。

上面的一些说法比较抽象，为了验证上述说法，写几个demo来验证一下。

一、中断和中断检查

1、interrupt方法可能不会中断线程

首先得明确第一个问题：interrupt方法是用于中断线程的方法，但是实际如果线程内没有sleep等阻塞方法，它实际上并不会中断线程，就算有sleep等方法执行，但是如果将异常捕获了，那它也不会中断线程的执行。看以下代码：

public class ThreadTest1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            int i = 0;
            while (true) {
                System.out.println(i++);
            }
        }
    }
}

运行该程序，将会进入死循环，不断打印i的自增值，最后整型溢出也不会停止，主线程调用的interrupt方法根本无法阻止线程继续运行。

正是之前所说的，“interrupt方法只是改变了被调用线程的内部中断状态“，那如何检查线程的中断状态呢？

2、isInterrupted实例方法检查中断状态

接下来我们调用Thread类的isInterrupted实例方法来检查线程的中断状态

public class ThreadTest2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }   

        @Override
        public void run() {
            //检查两次中断状态，都是true
            System.out.println("first:"+Thread.currentThread().isInterrupted());
            System.out.println("second:"+Thread.currentThread().isInterrupted());
            System.out.println("task " + name + " is over");
        }
    }
}

上述代码的运行结果如下

first:true
second:true
task mytask is over

主线程调用了中断方法，线程内调用线程的isInterrupted方法，输出都是true，表示都检测到了中断。为什么要输出两次一模一样的检测结果呢？是为了验证第一次调用的isInterrupted方法并没有改变中断状态。

3、interrupted静态方法检查中断状态

interrupted方法是Thread类的静态方法，它也能检查当前线程的中断状态，但是只能检查一次：这个静态方法有个天坑，它返回中断状态之后，会将中断标志复位成false，所以第二次调用该静态方法就会发现中断标志被改变了。

public class ThreadTest3 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }   

        @Override
        public void run() {
            //第一次调用返回中断状态，并将中断状态复位
            System.out.println("first :" + Thread.interrupted());
            //第二次调用返回复位后的中断状态
            System.out.println("second:" + Thread.interrupted());
            System.out.println("task " + name + " is over");
        }
    }
}

中断代码的输出结果为

first :true
second:false
task mytask is over

可以看到，重复调用Thread.interrupted()方法，得到的结果并不一样，原因就是第一次调用的时候中断状态被复位了。

二、中断抛异常的情况讨论

1、阻塞中断并抛出异常

既然是中断方法，那它肯定能在某些情况下中断线程的执行，什么情况下呢？就是在大多数阻塞方法下，比如线程正在sleep、wait、join等。

看下以下代码示例

public class ThreadTest {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(new Task("mytask"));
        t.start();
        t.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println("thread has been interrupt!");
            }
//            阻塞情况下中断，抛出异常后线程恢复非中断状态，即 interrupted = false
            System.out.println("isInterrupted: " +
                    Thread.currentThread().isInterrupted());
            System.out.println("task " + name + " is over");
        }
    }
}

它的运行结果如下

thread has been interrupt!
isInterrupted: false
task mytask is over

线程在sleep期间被中断并抛出了InterruptedException异常，抛出异常后立即重置了中断状态，所以接下来的检查中断方法得到的结果是false。

2、interrupted不会中断锁阻塞

对于sleep等阻塞方法，遇到interrupt中断方法会抛出异常，但是对于锁阻塞，则不会，看以下案例

public class ThreadTest4 {
    public static void main(String[] args) throws InterruptedException {
        Task mytask = new Task("mytask");
        Thread t1 = new Thread(mytask);
        Thread t2 = new Thread(mytask);
        t1.start();
        t2.start();
        t2.interrupt();
    }

    static class Task implements Runnable {
        String name;

        public Task(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            synchronized (this) {
                System.out.println(new Date() + "：" + Thread.currentThread().getName() + "： start run");
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    System.out.println(new Date() + "：" + Thread.currentThread().getName() + "：catch interrupted exception");
                
                }
            }
            System.out.println(new Date() + "：" + Thread.currentThread().getName() + "：" + Thread.currentThread().isInterrupted());
        }
    }
}

该程序运行结果如下

Fri Jun 14 15:11:52 CST 2024：Thread-0： start run
Fri Jun 14 15:11:55 CST 2024：Thread-1： start run
Fri Jun 14 15:11:55 CST 2024：Thread-0：false
Fri Jun 14 15:11:55 CST 2024：Thread-1：catch interrupted exception
Fri Jun 14 15:11:55 CST 2024：Thread-1：false

线程0持有锁之后等待了3秒钟，在等待期间，线程1尝试进入方法区，但是拿不到锁，所以进不去，进入锁等待状态，这时候主线程调用了线程1的线程中断方法interrupt，但是线程1并没有任何反映，等待线程0释放了锁之后，拿到锁，这时候它开始执行sleep方法，由于线程中断，抛出了InterruptedException，所以它“没睡”，直接打印信息后结束了线程。

如果我们不想线程1抛出异常，该怎么做呢？其实只需要稍微修改一点代码：

System.out.println(new Date() + "：" + Thread.currentThread().getName() + "： start run");

将上面这行代码改成下面这样子

System.out.println(new Date() + "：" + Thread.currentThread().getName() +"：" + Thread.interrupted() + "： start run");

只是进入方法区之后加了一点点逻辑：Thread.interrupted()

再次执行上面的主方法，得到的结果为

Fri Jun 14 15:20:09 CST 2024：Thread-0：false： start run
Fri Jun 14 15:20:12 CST 2024：Thread-1：true： start run
Fri Jun 14 15:20:12 CST 2024：Thread-0：false
Fri Jun 14 15:20:15 CST 2024：Thread-1：false

现成1不抛异常了，而且正常等待了3秒钟。。。可见，Thread.interrupted方法真是个隐藏的bug方法啊

三、总结

1、调用interrupt方法中断线程实际上只是设置了中断标志，只有线程在执行sleep、wait等阻塞的方法的时候才会抛出中断异常，但是并不会中断锁阻塞；中断抛出异常后会重置中断状态为false

2、可以调用Thread类的isInterrupted实例方法检测线程的中断状态，该方法不会重置中断状态为false

3、可以调用Thread类的interrupted静态方法检测线程的中断状态，该方法会重置中断状态为false，所以要慎用。

最后都看到这里了，欢迎光临我的个人博客：https://blog.kdyzm.cn ~

java

与java多线程编程：你真的了解线程中断吗？相似的内容：

java多线程编程：你真的了解线程中断吗？

java.lang.Thread类有一个 interrupt 方法，该方法直接对线程调用。当被interrupt的线程正在sleep或wait时，会抛出 InterruptedException 异常。事实上， interrupt 方法只是改变目标线程的中断状态（interrupt status），...

java
5
Java CompletableFuture 异步超时实现探索

JDK 8 是一次重大的版本升级，新增了非常多的特性，其中之一便是 CompletableFuture。自此从 JDK 层面真正意义上的支持了基于事件的异步编程范式，弥补了 Future 的缺陷。 在我们的日常优化中，最常用手段便是多线程并行执行。这时候就会涉及到 CompletableFuture 的使用。

java completablefuture 异步 超时
357
当面试官问出“Unsafe”类时，我就知道这场面试废了，祖坟都能给你问出来！

一、写在开头 依稀记得多年以前的一场面试中，面试官从Java并发编程问到了锁，从锁问到了原子性，从原子性问到了Atomic类库（对着JUC包进行了刨根问底），从Atomic问到了CAS算法，紧接着又有追问到了底层的Unsafe类，当问到Unsafe类时，我就知道这场面试废了，这似乎把祖坟都能给问冒烟

unsafe
0
Netty-介绍-1

Netty介绍和应用场景 要求 已经掌握了 主要技术构成： Java OOP 编程、 Java 多线程编程、 Java IO 编程 、 Java 网络编程、 常用的Java 设计模式(比如 观察者模式 ，命令模式，职责链模式 )、 常用的数据结构(比如 链表) Netty的介绍 1、Netty 是由

netty 介绍
58
Netty-架构设计及入门程序-3

一、原生 NIO 存在的问题 1、NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。2、需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor

netty 架构设计 入门 程序
378
JAVA多线程并发编程-避坑指南

本篇旨在基于编码规范、工作中积累的研发经验等，整理在多线程开发的过程中需要注意的部分，比如不考虑线程池参数、线程安全、死锁等问题，将会存在潜在极大的风险。并且对其进行根因分析，避免每天踩一坑，坑坑不一样。

java 多线程 并发 编程
138
[转帖]Java中线程的生命周期

https://blog.51cto.com/u_15773567/5832430 1 介绍 本篇文章我们讨论下Java中的一个非常核心的概念：线程的生命周期。在Java编程语言中，多线程编程非常重要。线程从创建到销毁是有生命周期的，在线程的生命周期中，线程会经历多种状态(state)。 2 线程状

java 中线 生命周期
0
解锁Java面试中的锁：深入了解不同类型的锁和它们的用途

简介 多线程编程在现代软件开发中扮演着至关重要的角色。它使我们能够有效地利用多核处理器和提高应用程序的性能。然而，多线程编程也伴随着一系列挑战，其中最重要的之一就是处理共享资源的线程安全性。在这个领域，锁（Lock）是一个关键的概念，用于协调线程之间对共享资源的访问。本文将深入探讨Java中不同类型

解锁 java 面试 深入
42
Java并发Map的面试指南：线程安全数据结构的奥秘

简介 在计算机软件开发的世界里，多线程编程是一个重要且令人兴奋的领域。然而，与其引人入胜的潜力相伴而来的是复杂性和挑战，其中之一就是处理共享数据。当多个线程同时访问和修改共享数据时，很容易出现各种问题，如竞态条件和数据不一致性。 本文将探讨如何在Java中有效地应对这些挑战，介绍一种强大的工具——并

java 并发 map 面试
194
实战分析Java的异步编程，并通过CompletableFuture进行高效调优

一、写在开头 在我们一开始讲多线程的时候，提到过异步与同步的概念，这里面我们再回顾一下： 同步：调用方在调用某个方法后，等待被调用方返回结果；调用方在取得被调用方的返回值后，再继续运行。调用方顺序执行，同步等待被调用方的返回值，这就是阻塞式调用； 异步：调用方在调用某个方法后，直接返回，不需要等待被

java completablefuture
0
# 热门排行
微软 New Bing AI 申请与使用保姆级教程（免魔法） ChatGPT API使用介绍 ChatGPT开发实战 一篇带你了解如何使用纯前端类Excel表格构建现金流量表 手把手教你玩转 Excel 数据透视表 为什么 C# 可能是最好的第一编程语言 .NET 入门到高级路线 提高工作效率的神器：基于前端表格实现Chrome Excel扩展插件 React + Springboot + Quartz，从0实现Excel报表自动化 用Echarts实现前端表格引用从属关系可视化
© PmDaddy. 2023 PmDaddy教程网 All rights reserved.