Java线程生命周期管理：启动、暂停与安全停止的最佳实践

// 假设 main 是 MyRunnable 的一个实例
Thread myThread = new Thread(main);
myThread.start();

while (running) {
    if (!paused) {
        // 执行工作
        System.out.println("thread working: " + counter);
        counter++;
        sleep(); // 只有在未暂停时才休眠
    }
}

while (running) {
    if (!paused) {
        System.out.println("thread working: " + counter);
        counter++;
    }
    // 无论是否暂停，都进行休眠，避免忙等待
    sleep(); 
}

import java.util.logging.Logger; // 使用java.util.logging作为示例

public class MyRunnable implements Runnable {
    private static final Logger LOGGER = Logger.getLogger(MyRunnable.class.getName());

    private volatile boolean running = false; // 线程是否应该运行
    private volatile boolean paused = false;  // 线程是否应该暂停

    @Override
    public void run() {
        LOGGER.info("MONITORING STARTED");
        running = true; // 确保线程启动时running为true
        paused = false; // 确保线程启动时paused为false
        int counter = 0;

        while (running) { // 检查running标志
            if (!paused) { // 检查paused标志
                System.out.println("thread working: " + counter);
                counter++;
            }
            // 无论是否暂停，都在每次循环迭代中休眠，避免CPU空转
            sleepSafely(1000); 
        }
        LOGGER.info("MONITORING STOPPED"); // 线程退出循环时记录停止信息
    }

    /**
     * 设置线程的运行状态。
     * @param running true表示运行，false表示停止
     */
    public void setRunning(boolean running) {
        if (!running && this.running) { // 只有在从运行变为停止时才记录
            LOGGER.info("APPLICATION STOPPING request received.");
        } else if (running && !this.running) { // 从停止变为运行（理论上不发生，因为run()只执行一次）
            LOGGER.info("APPLICATION STARTING request received.");
        }
        this.running = running;
    }

    /**
     * 设置线程的暂停状态。
     * @param paused true表示暂停，false表示继续
     */
    public void setPaused(boolean paused) {
        if (paused && !this.paused) {
            LOGGER.info("APPLICATION PAUSED = TRUE");
        } else if (!paused && this.paused) {
            LOGGER.info("APPLICATION PAUSED = FALSE (continues to work...)");
        }
        this.paused = paused;
    }

    /**
     * 安全地休眠指定时间，并处理中断。
     * @param millis 休眠时间（毫秒）
     */
    private void sleepSafely(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException ex) {
            // 当sleep被中断时，通常意味着线程应该停止或响应中断
            LOGGER.info("Thread sleep interrupted. Preparing to stop if running flag is false.");
            // 重新设置中断状态，以便run()方法中的while(running)可以检测到，
            // 或者更高层的代码可以处理中断。
            // 这里我们依赖running标志来终止循环。
            Thread.currentThread().interrupt(); 
            // 此时可以根据需要设置running = false; 确保线程退出
            // setRunning(false); // 如果希望中断直接导致线程停止，可以 uncomment 此行
        }
    }
}

import javax.swing.*; // 假设使用Swing作为UI框架
import java.awt.event.ActionListener;
import java.util.logging.Logger;

public class ThreadControlUI {

    private static final Logger LOGGER = Logger.getLogger(ThreadControlUI.class.getName());

    private MyRunnable mainRunnable;
    private Thread workerThread;

    public ThreadControlUI() {
        mainRunnable = new MyRunnable();
        workerThread = new Thread(mainRunnable); // 初始线程实例

        // 模拟UI按钮
        JButton startButton = new JButton("Start");
        JButton pauseButton = new JButton("Pause");
        JButton stopButton = new JButton("Stop");

        startButton.addActionListener(e -> {
            if (workerThread.getState() == Thread.State.NEW) {
                workerThread.start();
                mainRunnable.setRunning(true); // 确保Runnable内部状态同步
            } else if (workerThread.getState() == Thread.State.TERMINATED) {
                // 如果线程已停止，需要创建新的线程实例才能再次启动
                LOGGER.warning("Thread already terminated. Creating a new thread instance.");
                mainRunnable = new MyRunnable(); // 创建新的Runnable实例
                workerThread = new Thread(mainRunnable);
                workerThread.start();
                mainRunnable.setRunning(true);
            } else {
                // 线程可能处于暂停状态，恢复运行
                mainRunnable.setPaused(false);
            }
        });

        pauseButton.addActionListener(e -> {
            if (workerThread.isAlive() && !mainRunnable.paused) { // 确保线程活着且未暂停
                mainRunnable.setPaused(true);
            } else {
                LOGGER.info("Cannot pause: Thread is not alive or already paused.");
            }
        });

        stopButton.addActionListener(e -> {
            if (workerThread.isAlive()) { // 确保线程活着才能停止
                mainRunnable.setRunning(false); // 通知Runnable停止循环
                workerThread.interrupt();      // 中断线程，使其从阻塞状态（如sleep）中唤醒
                LOGGER.info("Stop request sent. Waiting for thread to terminate...");

                // 可选：等待线程终止，但要小心死锁
                // try {
                //     workerThread.join(5000); // 最多等待5秒
                // } catch (InterruptedException ex) {
                //     LOGGER.warning("Interrupted while waiting for thread to join.");
                //     Thread.currentThread().interrupt();
                // }

                // 停止后，如果需要再次启动，必须创建新的线程实例
                // 因为一个Thread实例只能start()一次
                mainRunnable = new MyRunnable(); // 为下次启动准备新的Runnable
                workerThread = new Thread(mainRunnable); // 创建新的Thread实例
            } else {
                LOGGER.info("Cannot stop: Thread is not alive.");
            }
        });

        // 实际应用中需要将这些按钮添加到JFrame或其他容器中
        JFrame frame = new JFrame("Thread Control");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new java.awt.FlowLayout());
        frame.add(startButton);
        frame.add(pauseButton);
        frame.add(stopButton);
        frame.pack();
        frame.setVisible(true);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(ThreadControlUI::new);
    }
}