掌握Java线程池任务的优雅终止：避免无限运行的陷阱

public class PrimeProducer extends Thread { // 继承了Thread
    private final BlockingQueue<BigInteger> queue;

    PrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            BigInteger p = BigInteger.ONE;
            while (!Thread.currentThread().isInterrupted()) { // 检查当前线程的中断状态
                queue.put(p = p.nextProbablePrime());
            }
        } catch (InterruptedException e) {
            // 捕获中断异常
        }
    }

    public void cancel() {
        interrupt(); // 调用 PrimeProducer 实例自身的中断方法
    }
}

public class PrimeProducer implements Runnable { // 实现Runnable
    private final BlockingQueue<BigInteger> queue;

    PrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            BigInteger p = BigInteger.ONE;
            while (!Thread.currentThread().isInterrupted()) {
                queue.put(p = p.nextProbablePrime());
            }
        } catch (InterruptedException e) {
            // 捕获中断异常
        }
    }

    public void cancel() {
        Thread.currentThread().interrupt(); // 试图中断当前线程
    }
}

import java.math.BigInteger;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class PrimeProducer implements Runnable {
    private final BlockingQueue<BigInteger> queue;
    private volatile boolean cancelled; // 使用 volatile 标志

    PrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            BigInteger p = BigInteger.ONE;
            while (!cancelled) { // 检查取消标志
                // 生产素数并放入队列，如果队列满会阻塞
                queue.put(p = p.nextProbablePrime());
            }
        } catch (InterruptedException e) {
            // 如果 queue.put() 阻塞时被中断，捕获异常
            // 此时 cancelled 可能为 false，但任务也应该停止
            System.out.println("PrimeProducer interrupted during put operation.");
            Thread.currentThread().interrupt(); // 重新设置中断标志，以便上层代码感知
        } finally {
            System.out.println("PrimeProducer stopped gracefully.");
        }
    }

    public void cancel() {
        cancelled = true; // 设置取消标志
        // 如果任务可能在阻塞操作（如queue.put()）中等待，
        // 可以选择在这里中断执行任务的线程，以尽快解除阻塞。
        // 但这通常由 ExecutorService.shutdown() 或 shutdownNow() 处理。
        // 对于本例，仅设置标志通常已足够。
    }

    // 示例方法：获取队列中的元素（非主要功能，仅为演示）
    public synchronized void get() {
        for (BigInteger i : queue) {
            System.out.println(i.toString());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        BlockingQueue<BigInteger> queue = new ArrayBlockingQueue<>(10);
        PrimeProducer generator = new PrimeProducer(queue);
        ExecutorService exec = Executors.newFixedThreadPool(1); // 创建一个单线程的线程池
        exec.execute(generator); // 提交任务到线程池

        try {
            Thread.sleep(1000); // 让素数生成器运行约1秒钟
        } catch (InterruptedException e) {
            System.out.println("Main thread interrupted.");
            Thread.currentThread().interrupt(); // 重新设置中断标志
        } finally {
            generator.cancel(); // 调用任务自身的取消方法
            System.out.println("Generator cancellation requested.");
        }

        exec.shutdown(); // 启动线程池的优雅关闭
        try {
            // 等待所有任务执行完毕，或最多等待5秒
            if (!exec.awaitTermination(5, TimeUnit.SECONDS)) {
                exec.shutdownNow(); // 如果超时，则强制关闭
                System.out.println("ExecutorService forced shutdown due to timeout.");
            }
        } catch (InterruptedException e) {
            exec.shutdownNow(); // 如果等待过程中主线程被中断，也强制关闭
            Thread.currentThread().interrupt();
            System.out.println("ExecutorService shutdown await interrupted.");
        }
        System.out.println("Main method finished.");
    }
}