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;
    }
}

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);
    }
}