Java中正确启动、暂停和停止线程的方法及问题咨询

现有实现的问题 #

你的实现能基本完成功能，但存在以下几个需要改进的点：

• 异常处理不规范：调用interrupt()触发Thread.sleep()抛出InterruptedException后，当前代码仅打印堆栈，却没有恢复线程的中断标志。捕获该异常时，JVM会自动清除线程的中断状态，若后续有依赖中断标志的逻辑，会导致无法感知中断。
• 依赖线程状态判断存在竞态风险：暂停按钮中通过ref.th.getState() == Thread.State.TIMED_WAITING判断线程状态，但线程状态是动态变化的，可能在判断完成后、调用setPaused(true)前，线程已从TIMED_WAITING回到RUNNABLE，导致暂停操作失效。
• 暂停逻辑存在忙等待：当paused为true时，while循环会持续空转，占用CPU资源，执行效率低下。

优化后的实现方案 #

核心优化思路 #

1. 用等待/通知机制替代忙等待，降低CPU消耗；
2. 正确处理InterruptedException，保留中断标志；
3. 移除对线程状态的依赖，通过标志位+中断状态共同控制线程生命周期，避免竞态条件。

优化后的代码 #

Runnable类实现

import java.util.logging.Logger;

public class MyRunnable implements Runnable {
    private volatile boolean running;
    private volatile boolean paused;
    private final Object pauseLock = new Object(); // 用于暂停等待的锁对象

    @Override
    public void run() {
        Logger.info("MONITORING STARTED");
        running = true;
        paused = false;
        int counter = 0;

        try {
            // 结合running标志和中断状态判断循环条件
            while (running && !Thread.currentThread().isInterrupted()) {
                // 处理暂停逻辑：进入等待直到暂停解除或线程停止
                synchronized (pauseLock) {
                    while (paused && running) {
                        pauseLock.wait();
                    }
                }

                // 再次检查状态，避免唤醒后线程已被要求停止
                if (!running || Thread.currentThread().isInterrupted()) {
                    break;
                }

                Thread.sleep(1000);
                System.out.println("thread working: " + counter);
                counter++;
            }
        } catch (InterruptedException e) {
            // 捕获中断异常后，重新设置中断标志，确保后续逻辑能感知
            Thread.currentThread().interrupt();
        } finally {
            Logger.info("MONITORING STOPPED");
            // 最终清理状态
            running = false;
            paused = false;
        }
    }

    public void setRunning(boolean running) {
        this.running = running;
        if (!running) {
            // 停止时唤醒等待中的线程，确保线程能快速退出
            synchronized (pauseLock) {
                pauseLock.notifyAll();
            }
        }
    }

    public void setPaused(boolean paused) {
        this.paused = paused;
        synchronized (pauseLock) {
            if (paused) {
                Logger.info("APPLICATION PAUSED = TRUE (paused)");
            } else {
                Logger.info("APPLICATION PAUSED = FALSE (continues to work...)");
                // 解除暂停时唤醒线程
                pauseLock.notifyAll();
            }
        }
    }
}

按钮事件处理代码

var ref = new Object() {
    Thread th = new Thread(main);
};

startItem.addActionListener(e -> {
    if (ref.th.getState() == Thread.State.NEW) {
        ref.th.start();
    } else {
        main.setPaused(false);
    }
});

pauseItem.addActionListener(e -> {
    // 不再依赖线程状态判断，直接设置暂停标志
    main.setPaused(true);
});

stopItem.addActionListener(e -> {
    main.setRunning(false);
    ref.th.interrupt();
    // 等待线程终止后再创建新线程，避免资源泄漏（根据业务场景可选）
    try {
        ref.th.join();
    } catch (InterruptedException ex) {
        Thread.currentThread().interrupt();
    }
    ref.th = new Thread(main);
});

优化点说明 #

• 避免忙等待：通过pauseLock.wait()让线程在暂停时进入等待状态，释放CPU资源，直到被唤醒才继续执行；
• 规范中断处理：捕获InterruptedException后调用Thread.currentThread().interrupt()恢复中断标志，保证线程中断状态的一致性；
• 消除竞态条件：移除对Thread.getState()的依赖，直接通过标志位控制逻辑，避免因线程状态动态变化导致的操作失效；
• 快速响应停止：停止时唤醒等待中的线程，确保线程能立即退出循环，无需等待Thread.sleep()结束。

内容的提问来源于stack exchange，提问作者Rigid