Java高并发下线程中断的几种方式详解

通过共享变量控制线程退出

最简单且直观的方式是利用一个volatile修饰的布尔变量作为“开关”。当该变量变为true时，线程循环条件失效从而退出。

第1步：定义带有信号控制的线程类

• 入口：创建一个继承自Thread的内部类或独立类。
• 动作：在run方法中使用while(true)进行业务循环，并在每次迭代中检查exit变量的值。
• 关键参数：exit变量必须声明为static volatile。如果不加volatile关键字，其他线程对exit的修改可能因为工作内存缓存而无法立即被当前线程感知，导致死循环。

package com.itsoku.chat05;
import java.util.concurrent.TimeUnit;

public class Demo1 {
    // 必须使用 volatile 保证多线程可见性
    public volatile static boolean exit = false;
    
    public static class T extends Thread {
        @Override
        public void run() {
            while (true) {
                // 模拟业务处理
                if (exit) {
                    break;
                }
            }
        }
    }
    
    public static void setExit() {
        exit = true;
    }
    
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        // 主线程休眠3秒，确保子线程有时间运行
        TimeUnit.SECONDS.sleep(3);
        setExit();
    }
}

利用线程自带中断标志控制

Java线程内部维护了一个中断标志位。调用Thread.interrupt()会将该标志位置为true，而isInterrupted()用于读取该状态。这种方式无需额外的共享变量。

第2步：在循环中轮询中断状态

• 入口：创建一个新的Thread子类。
• 动作：在run方法的循环体内，不检查外部变量，而是直接判断this.isInterrupted()的返回值。
• 重要参数：主线程调用子线程实例的interrupt()方法来触发中断信号。

package com.itsoku.chat05;
import java.util.concurrent.TimeUnit;

public class Demo2 {
    public static class T extends Thread {
        @Override
        public void run() {
            while (true) {
                // 检查线程的中断标志
                if (this.isInterrupted()) {
                    break;
                }
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        TimeUnit.SECONDS.sleep(3);
        // 触发中断标志
        t.interrupt();
    }
}

处理阻塞状态下的线程中断

当线程处于阻塞状态（例如调用sleep(), wait(), join()）时，简单的标志位检测会失效，因为代码停在阻塞处无法执行到判断逻辑。此时需要依赖异常机制。

在阻塞状态下调用interrupt()会触发两个结果：

1. 抛出InterruptedException异常，将程序从阻塞态唤醒至运行态。
2. 自动清除线程内部的中断标志位（即重置为false）。

第3步：捕获异常并恢复中断状态

• 准备条件：线程在执行TimeUnit.SECONDS.sleep()等耗时阻塞操作。
• 操作：在try-catch块中捕获InterruptedException。
• 关键点：在catch块中，必须在打印堆栈信息后再次调用this.interrupt()。这是因为之前的阻塞操作已经清除了中断标志，如果不在这里恢复，外部的isInterrupted()检查将无法发现中断请求，导致线程继续运行。

package com.itsoku.chat05;
import java.util.concurrent.TimeUnit;

public class Demo3 {
    public static class T extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    // 模拟阻塞代码
                    TimeUnit.SECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 核心步骤：恢复中断标志
                    this.interrupt();
                }
                // 判断是否被中断
                if (this.isInterrupted()) {
                    break;
                }
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        // 仅启动线程，此处若不主动调用 t.interrupt()，线程将一直休眠
        // TimeUnit.SECONDS.sleep(3);
        // t.interrupt();
    }
}

执行流程解析：

1. 主线程调用t.interrupt()，子线程中断标志置true。
2. 子线程因处于sleep状态，抛出InterruptedException，标志位被系统重置为false。
3. 进入catch块，手动调用this.interrupt()将标志位再次置为true。
4. 跳出try-catch后，执行if (this.isInterrupted())判定为真，break退出循环。

总结

在线程管理中，应根据场景选择中断方式：
1. **非阻塞场景**：优先使用volatile标志位或轮询isInterrupted()，简单且开销小。
2. **阻塞场景**：必须结合异常捕获处理，并务必在catch中恢复中断状态，否则会导致“静默”失败。
3. 实际开发中，建议组合使用这些策略，确保线程能够被可靠且安全地终止。

以上就是Java高并发下线程中断的几种方式详解的详细内容，更多关于Java并发编程的资料请关注本站其它相关文章！