import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 工作线程：持续从任务队列中取出并执行任务
 */
class Worker extends Thread {
    private final BlockingQueue<Runnable> taskQueue;
    private volatile boolean running = true; // 控制运行状态

    public Worker(BlockingQueue<Runnable> queue, String name) {
        super(name);
        this.taskQueue = queue;
    }

    @Override
    public void run() {
        try {
            while (running) {
                // 阻塞等待任务（若队列为空则挂起）
                Runnable task = taskQueue.take();
                
                // 检查是否收到终止信号（“毒丸” 一种优雅终止消费者线程的经典模式）
                if (task == SimpleThreadPool.POISON_PILL) {
                    System.out.println(getName() + " 收到终止信号，即将退出");
                    break;
                }

                // 执行任务
                task.run();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); // 恢复中断状态
        }
    }

    /**
     * 请求关闭工作线程（配合 interrupt 唤醒阻塞的 take()）
     */
    public void shutdown() {
        running = false;
        interrupt(); // 唤醒可能阻塞在 take() 上的线程
    }
}

/**
 * 简易线程池实现
 */
class SimpleThreadPool {
    // 终止信号：“毒丸”（一个特殊的空任务）
    static final Runnable POISON_PILL = () -> {};

    private final BlockingQueue<Runnable> taskQueue;
    private final Worker[] workers;

    /**
     * 构造线程池
     * @param poolSize 线程数量
     */
    public SimpleThreadPool(int poolSize) {
        this.taskQueue = new LinkedBlockingQueue<>();
        this.workers = new Worker[poolSize];

        // 启动所有工作线程
        for (int i = 0; i < poolSize; i++) {
            workers[i] = new Worker(taskQueue, "工作线程-" + (i + 1));
            workers[i].start();
        }
    }

    /**
     * 提交一个任务到队列
     */
    public void submit(Runnable task) {
        taskQueue.offer(task); // 非阻塞提交
    }

    /**
     * 优雅关闭线程池：
     * 向队列中放入与工作线程数量相同的“毒丸”，通知它们退出
     */
    public void shutdown() {
        for (Worker worker : workers) {
            taskQueue.offer(POISON_PILL);
        }
    }
}

/**
 * 测试简易线程池
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {
        SimpleThreadPool pool = new SimpleThreadPool(3); // 创建含 3 个工作线程的池

        // 提交 5 个任务
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            pool.submit(() -> {
                System.out.println("正在执行任务 " + taskId + 
                                   "，由 " + Thread.currentThread().getName() + " 处理");
                try {
                    Thread.sleep(1000); // 模拟耗时操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // 关闭线程池
        pool.shutdown();
        
        // 可选：等待所有线程结束（非必须，但便于观察输出）
        for (Thread worker : pool.workers) {
            try {
                worker.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        System.out.println("线程池已完全关闭");
    }
}

正在执行任务 1，由 工作线程-1 处理
正在执行任务 2，由 工作线程-2 处理
正在执行任务 3，由 工作线程-3 处理
正在执行任务 4，由 工作线程-1 处理
正在执行任务 5，由 工作线程-2 处理
工作线程-3 收到终止信号，即将退出
工作线程-1 收到终止信号，即将退出
工作线程-2 收到终止信号，即将退出
线程池已完全关闭

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class StandardThreadPoolDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        for (int i = 1; i <= 5; i++) {
            int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + 
                                   " executed by " + Thread.currentThread().getName());
            });
        }

        executor.shutdown(); // 不再接受新任务，但会完成已提交任务
    }
}