本文深入探讨了在Java中优雅地管理线程生命周期的方法，涵盖了线程的启动、暂停与停止操作。我们将重点介绍如何利用`volatile`关键字确保线程间状态同步，通过`Thread.interrupt()`机制安全地中断线程，并正确处理`InterruptedException`以避免资源泄漏和不必要的错误日志。此外，文章还将优化线程暂停时的CPU利用率，并提供完整的代码示例及推荐的最佳实践，旨在帮助开发者构建健壮、高效的多线程应用。
线程状态管理的核心概念
在Java中，对线程的启动、暂停和停止进行精细化控制是多线程编程的关键。直接使用Thread.stop()、Thread.suspend()和Thread.resume()方法已被弃用，因为它们可能导致死锁或资源损坏。现代Java推荐通过共享变量和interrupt()机制来协作式地管理线程。
核心思想是：
- 共享状态变量：使用volatile修饰的布尔变量来控制线程的运行和暂停状态。volatile确保了这些变量在多线程环境中的可见性，避免了缓存不一致问题。
- 中断机制：利用Thread.interrupt()方法来通知目标线程它应该停止当前正在执行的阻塞操作（如sleep()、wait()、join()），并响应中断请求。
实现可控的Runnable类
首先，我们定义一个实现了Runnable接口的类，它将包含线程的实际工作逻辑以及控制其状态的变量和方法。
立即学习“Java免费学习笔记（深入）”；
import java.util.logging.Logger; // 使用java.util.logging替代Logger.info
public class MyRunnable implements Runnable {
private static final Logger logger = Logger.getLogger(MyRunnable.class.getName());
// volatile确保running和paused变量的可见性
private volatile boolean running;
private volatile boolean paused;
@Override
public void run() {
logger.info("MONITORING STARTED");
running = true;
paused = false;
int counter = 0;
while (running) {
// 优化：无论是否暂停，都应该有休眠，避免CPU空转
try {
// 如果暂停，线程在此处等待，不执行工作逻辑
// 如果未暂停，执行工作逻辑后休眠
if (!paused) {
System.out.println("thread working: " + counter);
counter++;
}
Thread.sleep(1000); // 统一休眠，避免CPU空转
} catch (InterruptedException ex) {
// 收到中断信号，通常意味着外部请求停止线程
// 1. 记录日志，说明线程被中断
logger.info("Thread was interrupted while sleeping.", ex);
// 2. 清除中断状态（可选，如果需要继续处理中断后的逻辑）
Thread.currentThread().interrupt(); // 重新设置中断状态，供上层或后续代码处理
// 3. 退出循环，停止线程
running = false;
}
}
logger.info("MONITORING STOPPED (Thread exited loop)");
}
/**
* 设置线程的运行状态。当设置为false时，线程将停止。
* @param running true表示运行，false表示停止。
*/
public void setRunning(boolean running) {
if (!running) {
logger.info("MONITORING STOPPED (External call)");
}
this.running = running;
}
/**
* 设置线程的暂停状态。
* @param paused true表示暂停，false表示继续。
*/
public void setPaused(boolean paused) {
if (paused) {
logger.info("APPLICATION PAUSED = TRUE (paused)");
} else {
logger.info("APPLICATION PAUSED = FALSE (continues to work...)");
}
this.paused = paused;
}
}关键改进点：
- volatile 关键字：running和paused变量必须声明为volatile，以确保对它们的所有写操作都立即刷新到主内存，并且所有读操作都从主内存中读取，保证了多线程间的可见性。
- sleep() 位置优化：将Thread.sleep(1000)移到if (!paused)块的外部。这意味着无论线程是否暂停，它都会周期性地休眠。这样可以避免在线程暂停时，while(running)循环空转，导致CPU占用率过高的问题。
-
InterruptedException 处理：当Thread.sleep()被Thread.interrupt()中断时，会抛出InterruptedException。在这里，我们不再简单地printStackTrace()，而是：
- 记录日志，说明中断是预期的行为。
- 通过running = false;来设置停止标志，使while循环退出，从而优雅地终止线程。
- Thread.currentThread().interrupt(); 重新设置中断状态，这是一种最佳实践，因为捕获InterruptedException会清除当前线程的中断状态。如果当前方法无法完全处理中断，重新设置中断状态可以确保调用栈上层或后续代码能够感知到中断。
控制线程的启动、暂停与停止
接下来，我们将实现控制线程生命周期的逻辑，通常这会绑定到UI事件或命令。
import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class ThreadControlPanel {
private MyRunnable mainRunnable;
private Thread workerThread;
public ThreadControlPanel() {
// 初始化Runnable和Thread
mainRunnable = new MyRunnable();
workerThread = new Thread(mainRunnable);
// 示例UI按钮（假设有这些按钮）
JButton startItem = new JButton("Start");
JButton pauseItem = new JButton("Pause");
JButton stopItem = new JButton("Stop");
startItem.addActionListener(e -> startThread());
pauseItem.addActionListener(e -> pauseThread());
stopItem.addActionListener(e -> stopThread());
// 可以在这里添加这些按钮到一个JFrame或其他容器
JFrame frame = new JFrame("Thread Control");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel panel = new JPanel();
panel.add(startItem);
panel.add(pauseItem);
panel.add(stopItem);
frame.add(panel);
frame.pack();
frame.setVisible(true);
}
private void startThread() {
// 只有当线程处于NEW状态时才调用start()
if (workerThread.getState() == Thread.State.NEW) {
workerThread.start();
mainRunnable.setPaused(false); // 确保启动后不是暂停状态
} else if (workerThread.getState() == Thread.State.TERMINATED) {
// 如果线程已终止，需要创建新的Runnable和Thread实例才能再次启动
System.out.println("Thread already terminated. Creating new thread.");
mainRunnable = new MyRunnable();
workerThread = new Thread(mainRunnable);
workerThread.start();
mainRunnable.setPaused(false);
} else {
// 如果线程已经运行或暂停，只需将其设置为非暂停状态
mainRunnable.setPaused(false);
}
}
private void pauseThread() {
// 只有当线程处于运行状态时才允许暂停
// TIMED_WAITING是sleep()后的状态，RUNNABLE是正常运行状态
if (workerThread.isAlive() && !mainRunnable.paused) { // 避免重复设置暂停
mainRunnable.setPaused(true);
}
}
private void stopThread() {
// 首先设置running标志为false，通知线程停止其工作循环
mainRunnable.setRunning(false);
// 然后中断线程，唤醒可能正在sleep()或wait()的线程
if (workerThread.isAlive()) { // 只有活着的线程才能被中断
workerThread.interrupt();
try {
// 等待线程终止，避免主线程过早退出
workerThread.join(5000); // 最多等待5秒
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断状态
System.err.println("Waiting for worker thread to terminate was interrupted.");
}
}
// 可选：如果需要再次启动，需要创建新的Thread实例
// workerThread = new Thread(mainRunnable); // 线程对象是单次使用的
System.out.println("Thread stop initiated.");
}
public static void main(String[] args) {
SwingUtilities.invokeLater(ThreadControlPanel::new);
}
}关键改进点：
- 线程的单次使用性：一个Thread对象只能start()一次。如果线程已经终止（TERMINATED状态），需要创建新的Runnable实例和新的Thread实例才能再次启动。
- workerThread.isAlive()检查：在调用interrupt()之前检查线程是否仍然存活，可以避免对已终止线程的操作。
- Thread.join()：在停止线程后，使用workerThread.join()可以等待工作线程完成其清理工作并终止，这有助于确保资源的正确释放。设置超时时间（如join(5000)）可以防止无限期等待。
最佳实践与注意事项
- 避免使用Thread.stop()、Thread.suspend()和Thread.resume()：这些方法已被弃用，因为它们是不安全的，可能导致数据不一致和死锁。
- 使用volatile确保可见性：任何用于控制线程状态的共享变量都应声明为volatile，以保证所有线程都能看到最新的值。
-
正确处理InterruptedException：当线程被中断时，InterruptedException会被抛出。捕获此异常后，通常应执行以下操作之一：
- 终止线程：设置一个标志位使run()方法退出。
- 重新设置中断状态：调用Thread.currentThread().interrupt()，以便调用栈上层代码可以感知到中断。
- 不应忽略：简单地catch (InterruptedException e) { /* do nothing */ }是糟糕的做法，因为它会吞噬中断信号，导致线程无法被正确停止。
- 避免忙等待（Busy Waiting）：当线程暂停时，不应让它在一个紧密的循环中空转检查状态。使用Thread.sleep()、Object.wait()或Lock.newCondition().await()可以释放CPU资源。
- 线程池（ExecutorService）：在实际应用中，直接创建和管理Thread对象通常不是最佳选择。推荐使用java.util.concurrent.ExecutorService来管理线程池，它提供了更高级别的抽象，可以更方便地提交任务、管理线程生命周期、处理任务结果等。
- 线程的单次使用性：Thread对象一旦启动并执行完毕，就不能再次start()。如果需要重复执行任务，应该创建新的Thread实例或使用线程池。
总结
通过volatile变量和Thread.interrupt()机制，我们可以实现对Java线程的优雅启动、暂停和停止。关键在于：
- 使用volatile布尔标志控制线程的运行和暂停状态。
- 将Thread.sleep()等阻塞操作放在合适的位置，并正确处理InterruptedException，通常是设置running标志为false并重新中断当前线程。
- 优化暂停逻辑，避免CPU空转。
- 理解Thread对象的生命周期，尤其是一个Thread实例只能start()一次。
- 在复杂的应用中，考虑使用ExecutorService来更有效地管理线程。
遵循这些最佳实践，可以帮助开发者构建出更健壮、响应更及时、资源利用率更高的多线程Java应用程序。
