Java多线程——3.中断线程

目录

• Java线程中断
  • join()方法与线程中断的协同使用
    • join()方法的基本特性
  • 线程中断
    • 中断相关的核心方法
  • 使用标志位中断线程
    • 基于volatile的标志位
  • 中断机制的两种响应方式
    • 1. 运行中的线程响应中断
    • 2. 等待中的线程响应中断
  • 中断机制注意事项
  • 总结

---

Java线程中断

join()方法与线程中断的协同使用

join()方法用于等待另一个线程完成，它与中断机制结合使用时可以实现更灵活的线程同步。

join()方法的基本特性

• 等待线程结束：调用join()会阻塞当前线程，直到目标线程执行完毕
• 指定等待时间：join(long millis)可以设置最大等待时间
• 已结束线程：对已终止的线程调用join()会立即返回

public class JoinWithInterrupt {
    public static void main(String[] args) {
        Thread worker = new Thread(() -> {
            try {
                System.out.println("工作线程开始执行");
                Thread.sleep(3000); // 模拟耗时任务
                System.out.println("工作线程执行完毕");
            } catch (InterruptedException e) {
                System.out.println("工作线程被中断");
            }
        });

        worker.start();

        Thread waiter = new Thread(() -> {
            try {
                System.out.println("等待线程开始等待");
                worker.join(2000); // 最多等待2秒
                if (worker.isAlive()) {
                    System.out.println("等待超时，发送中断请求");
                    worker.interrupt(); // 超时后中断工作线程
                    worker.join(); // 等待工作线程处理中断
                }
                System.out.println("等待线程结束");
            } catch (InterruptedException e) {
                System.out.println("等待线程自身被中断");
            }
        });

        waiter.start();
    }
}

这个示例展示了join()与中断的协同：等待线程先等待工作线程2秒，然后.isAlive()判断线程如果还存活，则主动中断工作线程并等待其退出。

线程中断

线程中断并非强制终止线程，而是一种协作机制——通过向目标线程发送中断信号，由目标线程自行决定是否响应中断并终止执行。这种设计避免了强制终止线程可能导致的资源泄露等问题。

中断相关的核心方法

Java提供了三个与中断相关的核心方法：

1. void interrupt()：向目标线程发送中断请求，设置中断标志位
2. boolean isInterrupted()：判断当前线程是否被中断（不清除中断标志）
3. static boolean interrupted()：判断当前线程是否被中断（清除中断标志）

public class InterruptBasic {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            int count = 0;
            // 检查中断标志位
            while (!Thread.currentThread().isInterrupted()) {
                count++;
                System.out.println("工作中... 计数：" + count);
                try {
                    Thread.sleep(100); // 模拟耗时操作
                } catch (InterruptedException e) {
                    // 捕获中断异常，再次设置中断标志
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("线程已响应中断，退出执行");
        });

        worker.start();
        Thread.sleep(1000); // 主线程等待1秒
        worker.interrupt(); // 发送中断请求
        worker.join(); // 等待线程执行完毕
        System.out.println("主线程结束");
    }
}

在这个示例中，工作线程通过isInterrupted()持续检查中断状态，当主线程调用interrupt()后，工作线程检测到中断信号并退出循环。

使用标志位中断线程

除了内置的中断机制，还可以使用自定义标志位控制线程终止，这种方式需要注意线程间的可见性。

基于volatile的标志位

public class FlagInterrupt {
    static class WorkerThread extends Thread {
        // 用volatile保证可见性
        public volatile boolean running = true;

        @Override
        public void run() {
            int count = 0;
            while (running) {
                count++;
                System.out.println("工作中... 计数：" + count);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    return;
                }
            }
            System.out.println("收到停止信号，退出");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        WorkerThread worker = new WorkerThread();
        worker.start();
        Thread.sleep(1000);
        worker.running = false; // 设置标志位终止线程
        worker.join(); // 等待线程结束
        System.out.println("主线程结束");
    }
}

volatile关键字确保了标志位在多线程间的可见性：

• 每次读取都从主内存获取最新值
• 每次修改后立即写入主内存
• 避免线程缓存导致的可见性问题

中断机制的两种响应方式

线程对中断的响应取决于其当前状态，主要有两种情况：

1. 运行中的线程响应中断

当线程处于运行状态时，需要主动检测isInterrupted()标志：

public class RunningInterrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                // 执行任务逻辑
                System.out.println("执行任务...");
            }
            System.out.println("收到中断信号，退出");
        });

        t.start();
        Thread.sleep(500);
        t.interrupt(); // 发送中断请求
        t.join(); // 等待线程结束
    }
}

这种方式要求线程在循环中定期检查中断状态，适合CPU密集型任务。

2. 等待中的线程响应中断

当线程处于wait()、sleep()、join()等等待状态时，收到中断请求会抛出InterruptedException：

public class WaitingInterrupt {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                System.out.println("线程进入等待状态");
                Thread.sleep(5000); // 长时间等待
            } catch (InterruptedException e) {
                System.out.println("在等待中收到中断信号");
                return; // 退出线程
            }
            System.out.println("线程正常结束");
        });

        t.start();
        Thread.sleep(1000);
        t.interrupt(); // 中断等待中的线程
        t.join(); // 等待线程处理中断
    }
}

在等待状态中响应中断更及时，因为InterruptedException会立即唤醒线程。

中断机制注意事项

1. 及时响应中断：线程应尽快检测并响应中断请求，避免长时间忽略中断

2. 清理资源：收到中断后应先清理资源再退出（要是你采用继承Thread类或者实现Runnable接口的方式创建线程，在线程执行完毕后，系统会自动回收相关资源，无需手动调用.close()方法。）

   @Override
   public void run() {
       Resource resource = new Resource(); // 获取资源
       try {
           while (!isInterrupted()) {
               // 使用资源执行任务
           }
       } finally {
           resource.close(); // 确保资源被释放
           System.out.println("资源已清理");
       }
   }
   

3. 正确传递中断：捕获InterruptedException后如需继续执行，应重新设置中断标志

   try {
       Thread.sleep(100);
   } catch (InterruptedException e) {
       // 重新设置中断标志
       Thread.currentThread().interrupt();
       // 可以继续处理或退出
   }
   

4. 避免屏蔽中断：不要捕获InterruptedException后不做任何处理

   // 不推荐的做法
   try {
       Thread.sleep(100);
   } catch (InterruptedException e) {
       // 屏蔽了中断，线程无法响应
   }
   

总结

• join()方法可等待线程结束，支持超时设置并能被中断
• 中断是协作式机制，需目标线程主动响应
• 运行中的线程通过isInterrupted()检测中断
• 等待中的线程通过InterruptedException响应中断
• 自定义标志位需用volatile保证可见性