常用线程池与陷阱 ⭐⭐

// Executors 类的基本结构（简化版）
public class Executors {
 
    // 私有构造，禁止实例化 —— 纯工具类的标准写法
    private Executors() {}
 
    // 创建固定线程数的线程池
    public static ExecutorService newFixedThreadPool(int nThreads) {
        // 核心线程数 = 最大线程数 = nThreads
        // 使用无界的 LinkedBlockingQueue 作为工作队列
        return new ThreadPoolExecutor(
            nThreads,                          // corePoolSize: 核心线程数
            nThreads,                          // maximumPoolSize: 最大线程数（与核心相同）
            0L,                                // keepAliveTime: 空闲线程存活时间（0 表示不回收）
            TimeUnit.MILLISECONDS,             // 时间单位
            new LinkedBlockingQueue<Runnable>() // 工作队列：无界阻塞队列
        );
    }
 
    // 创建可缓存的线程池
    public static ExecutorService newCachedThreadPool() {
        // 核心线程数为 0，最大线程数为 Integer.MAX_VALUE
        // 使用不存储元素的 SynchronousQueue
        return new ThreadPoolExecutor(
            0,                                 // corePoolSize: 没有核心线程
            Integer.MAX_VALUE,                 // maximumPoolSize: 理论上无限
            60L,                               // keepAliveTime: 空闲 60 秒后回收
            TimeUnit.SECONDS,                  // 时间单位
            new SynchronousQueue<Runnable>()   // 工作队列：不存储任务的同步移交队列
        );
    }
 
    // 创建单线程的线程池
    public static ExecutorService newSingleThreadExecutor() {
        // 核心线程数 = 最大线程数 = 1
        // 使用 FinalizableDelegatedExecutorService 包装，使其不可被强转后修改参数
        return new FinalizableDelegatedExecutorService(
            new ThreadPoolExecutor(
                1,                             // corePoolSize: 仅 1 个核心线程
                1,                             // maximumPoolSize: 最大也是 1
                0L,                            // keepAliveTime: 不回收
                TimeUnit.MILLISECONDS,         // 时间单位
                new LinkedBlockingQueue<Runnable>() // 无界队列
            )
        );
    }
 
    // 创建定时/周期任务线程池
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        // 返回的是 ScheduledThreadPoolExecutor（ThreadPoolExecutor 的子类）
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
}

// ThreadPoolExecutor 的完整构造方法签名
public ThreadPoolExecutor(
    int corePoolSize,                  // 核心线程数：即使空闲也不会被回收的线程数量
    int maximumPoolSize,               // 最大线程数：线程池允许创建的线程上限
    long keepAliveTime,                // 空闲存活时间：非核心线程空闲多久后被销毁
    TimeUnit unit,                     // keepAliveTime 的时间单位
    BlockingQueue<Runnable> workQueue, // 工作队列：当核心线程全忙时，新任务在此排队
    ThreadFactory threadFactory,       // 线程工厂：控制线程的创建方式（名称、守护状态等）
    RejectedExecutionHandler handler   // 拒绝策略：队列满且线程数达到上限时的处理方式
)

// Executors 内部的默认线程工厂（简化版）
static class DefaultThreadFactory implements ThreadFactory {
    // 静态原子计数器：记录线程池编号（全局递增）
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    // 实例级原子计数器：记录当前线程池中的线程编号
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    // 线程组（Java 21+ 已弱化，但低版本中仍有意义）
    private final ThreadGroup group;
    // 线程名称前缀，格式为 "pool-{poolNumber}-thread-"
    private final String namePrefix;
 
    DefaultThreadFactory() {
        // 获取当前调用者的线程组
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        // 拼接线程名前缀，例如 "pool-1-thread-"
        namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
    }
 
    public Thread newThread(Runnable r) {
        // 创建新线程，名称格式："pool-1-thread-1", "pool-1-thread-2" ...
        Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
        // 强制设为非守护线程（daemon = false）
        if (t.isDaemon())
            t.setDaemon(false);
        // 强制设为普通优先级
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

// 使用 Guava 的 ThreadFactoryBuilder 创建具有业务语义名称的线程工厂
ThreadFactory namedFactory = new ThreadFactoryBuilder()
    .setNameFormat("order-processor-%d")       // 线程名格式：order-processor-0, order-processor-1 ...
    .setDaemon(false)                           // 非守护线程
    .setUncaughtExceptionHandler((t, e) ->      // 全局未捕获异常处理
        log.error("Thread {} threw exception", t.getName(), e))
    .build();
 
// 将自定义工厂传入 ThreadPoolExecutor
ExecutorService pool = new ThreadPoolExecutor(
    4, 8, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),             // 有界队列，容量 1000
    namedFactory,                               // 自定义线程工厂
    new ThreadPoolExecutor.CallerRunsPolicy()   // 拒绝策略：由调用者线程执行
);

// Executors 本质上就是 ThreadPoolExecutor 的"快捷方式"
// 下面这行代码背后，隐藏着一组精心挑选（但未必安全）的参数
ExecutorService pool = Executors.newFixedThreadPool(4);

// === JDK 源码：Executors.newFixedThreadPool ===
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(
        nThreads,                           // corePoolSize：核心线程数，固定为 nThreads
        nThreads,                           // maximumPoolSize：最大线程数，也固定为 nThreads
        0L,                                 // keepAliveTime：空闲存活时间为 0
        TimeUnit.MILLISECONDS,              // 时间单位：毫秒（此处实际无意义，因为 keepAliveTime=0）
        new LinkedBlockingQueue<Runnable>() // workQueue：无界阻塞队列 ⚠️ 这是关键
    );
}

// 创建线程池，此时内部线程数为 0
ExecutorService pool = Executors.newFixedThreadPool(3); // 线程数：0
 
pool.execute(task1); // 第 1 个任务 → 创建线程-1 执行，线程数：1
pool.execute(task2); // 第 2 个任务 → 创建线程-2 执行，线程数：2
pool.execute(task3); // 第 3 个任务 → 创建线程-3 执行，线程数：3（达到上限）
pool.execute(task4); // 第 4 个任务 → 所有线程都在忙，任务进入队列等待
pool.execute(task5); // 第 5 个任务 → 同上，继续排队

// 创建线程池
ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(3);
 
// 预启动所有核心线程，无需等待第一个任务到来
// 此方法返回实际启动的线程数量
int started = pool.prestartAllCoreThreads(); // started = 3，立即创建 3 个线程

// === 简化后的 Worker 运行逻辑 ===
// ThreadPoolExecutor 内部 Worker 线程的核心循环
while (task != null || (task = getTask()) != null) { // getTask() 内部调用 queue.take()
    task.run();                                       // 执行任务
    task = null;                                      // 清空引用，准备获取下一个任务
}
// 对于核心线程，getTask() 调用的是 queue.take()——一个无限阻塞方法
// 这意味着核心线程会永远等下去，不会退出循环，不会被回收

┌─────────────────── FixedThreadPool (nThreads = 3) ───────────────────┐
│                                                                       │
│   ┌──────────┐  ┌──────────┐  ┌──────────┐                          │
│   │ Thread-1 │  │ Thread-2 │  │ Thread-3 │    ← 固定 3 个核心线程    │
│   │ 执行task1│  │ 执行task2│  │ 执行task3│                          │
│   └──────────┘  └──────────┘  └──────────┘                          │
│         ▲              ▲             ▲                                │
│         │              │             │         take() 取任务          │
│   ┌─────┴──────────────┴─────────────┴──────┐                        │
│   │     LinkedBlockingQueue (无界队列)        │                        │
│   │  ┌───────┐  ┌───────┐  ┌───┐            │                        │
│   │  │ task4 │→ │ task5 │→ │...│  → 可以无限排队                     │
│   │  └───────┘  └───────┘  └───┘            │                        │
│   └─────────────────────────────────────────┘                        │
│                                                                       │
│   maximumPoolSize = 3 (与 core 相同，永远不会创建额外线程)            │
│   拒绝策略：理论上永远不会触发（队列无界）                             │
└───────────────────────────────────────────────────────────────────────┘

ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(4);
 
// 允许核心线程在空闲超过 keepAliveTime 后被回收
// 注意：此时 keepAliveTime 必须 > 0，否则抛出 IllegalArgumentException
pool.setKeepAliveTime(60, TimeUnit.SECONDS); // 先设置存活时间
pool.allowCoreThreadTimeOut(true);           // 再开启核心线程超时回收
 
// 此时如果 60 秒内没有新任务，核心线程也会被逐步销毁
// 线程池最终可能缩减到 0 个线程

// === LinkedBlockingQueue 关键源码（简化版）===
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E> {
 
    // 队列容量，默认 Integer.MAX_VALUE
    private final int capacity;
 
    // 当前队列中的元素个数（原子变量，保证线程安全）
    private final AtomicInteger count = new AtomicInteger();
 
    // 链表头节点（哨兵节点，不存储实际数据）
    transient Node<E> head;
 
    // 链表尾节点
    private transient Node<E> last;
 
    // 取元素的锁（消费者端）
    private final ReentrantLock takeLock = new ReentrantLock();
 
    // 放元素的锁（生产者端）
    private final ReentrantLock putLock = new ReentrantLock();
 
    // 无参构造器：容量为 Integer.MAX_VALUE —— 这就是"无界"的来源
    public LinkedBlockingQueue() {
        this(Integer.MAX_VALUE); // ⚠️ 约 21 亿，内存耗尽之前几乎不可能满
    }
 
    // 有参构造器：可以指定容量上限
    public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null); // 初始化哨兵节点
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class FixedPoolOOMDemo {
    public static void main(String[] args) {
        // 创建一个只有 1 个线程的 FixedThreadPool
        ExecutorService pool = Executors.newFixedThreadPool(1);
 
        // 模拟高并发场景：疯狂提交任务
        for (int i = 0; ; i++) { // 无限循环提交任务
            final int taskId = i;
            pool.execute(() -> {
                try {
                    // 每个任务执行耗时 1 秒（模拟数据库查询、HTTP调用等IO操作）
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Task-" + taskId + " done");
            });
            // 每次提交都会创建一个 Runnable 对象（含一个 lambda + 闭包变量）
            // 这些对象全部堆积在 LinkedBlockingQueue 中
            // 1 个线程每秒只能消费 1 个任务，但每秒可能提交上万个任务
        }
        // 运行参数建议：-Xmx32m  可以更快看到 OOM
        // 最终抛出：java.lang.OutOfMemoryError: Java heap space
    }
}

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
    at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
    ...

// 典型场景：Web 服务器处理请求
@RestController
public class OrderController {
 
    // ⚠️ 使用 FixedThreadPool 处理异步任务
    private final ExecutorService asyncPool = Executors.newFixedThreadPool(10);
 
    @PostMapping("/order")
    public Response createOrder(@RequestBody OrderRequest req) {
        // 同步处理核心逻辑
        Order order = orderService.create(req);
 
        // 异步发送通知（看似无害的操作）
        asyncPool.execute(() -> {
            notificationService.sendEmail(order);       // 可能耗时 2-5 秒
            notificationService.sendSMS(order);         // 可能耗时 1-3 秒
            thirdPartyService.syncToWarehouse(order);   // 可能耗时 5-10 秒
        });
 
        return Response.success(order);
    }
}
// 正常流量下一切正常：10个线程足以处理
// 大促期间：每秒 5000 个订单，每个异步任务需要 10 秒
// 10 个线程每秒只能消费 1 个任务（10/10=1）
// 每秒积压 4999 个 Runnable 到队列中
// 数小时后 → OOM → 服务宕机 → 所有订单处理中断

// 推荐做法：手动创建线程池，明确每一个参数
ThreadPoolExecutor pool = new ThreadPoolExecutor(
    10,                                    // corePoolSize：核心线程数
    20,                                    // maximumPoolSize：最大线程数（允许弹性扩容）
    60L,                                   // keepAliveTime：非核心线程空闲 60 秒后回收
    TimeUnit.SECONDS,                      // 时间单位
    new LinkedBlockingQueue<>(1000),       // ⭐ 有界队列！最多排 1000 个任务
    new ThreadFactoryBuilder()             // 自定义线程工厂（推荐 Guava 的 ThreadFactoryBuilder）
        .setNameFormat("order-async-%d")   // 给线程起有意义的名字，方便排查问题
        .build(),
    new ThreadPoolExecutor.CallerRunsPolicy() // ⭐ 拒绝策略：让调用者线程自己执行
    // CallerRunsPolicy 的妙处：当队列满时，提交任务的线程（如 Tomcat 的 Worker 线程）
    // 会自己执行这个任务，从而自然地降低了提交速度，形成天然的"背压（Back Pressure）"
);

// 如果确实需要"固定线程数"的语义，自己构造即可
ThreadPoolExecutor fixedPool = new ThreadPoolExecutor(
    10,                                     // corePoolSize = maximumPoolSize = 10
    10,                                     // 固定线程数
    0L,                                     // 核心线程不超时
    TimeUnit.MILLISECONDS,                  //
    new ArrayBlockingQueue<>(500),          // ⭐ 有界队列，容量 500
    new ThreadPoolExecutor.AbortPolicy()    // 队列满时直接抛 RejectedExecutionException
);
// 这样既保留了"固定线程数"的特性，又避免了无界队列导致的 OOM

ExecutorService pool = Executors.newFixedThreadPool(2);
for (int i = 0; i < 10_000_000; i++) {
    pool.execute(() -> {
        try { Thread.sleep(5000); } catch (InterruptedException e) {}
    });
}
System.out.println("All tasks submitted");

// java.util.concurrent.Executors 类中的工厂方法
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
        0,                          // corePoolSize: 核心线程数为 0
        Integer.MAX_VALUE,          // maximumPoolSize: 最大线程数约 21 亿
        60L,                        // keepAliveTime: 空闲线程存活时间 60 秒
        TimeUnit.SECONDS,           // 时间单位: 秒
        new SynchronousQueue<Runnable>()  // 工作队列: 同步移交队列
    );
}

// 演示线程池的弹性收缩
public class CachedPoolShrinkDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建缓存线程池
        ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
 
        // 提交 5 个任务, 会创建 5 个线程
        for (int i = 0; i < 5; i++) {
            pool.execute(() -> {
                // 打印当前线程名, 表明任务正在执行
                System.out.println(Thread.currentThread().getName() + " 执行任务");
                try {
                    Thread.sleep(1000); // 模拟耗时 1 秒的任务
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 恢复中断标志
                }
            });
        }
 
        // 任务刚提交完, 线程池中应有 5 个线程
        Thread.sleep(100); // 等待 100ms 让线程全部启动
        System.out.println("活跃线程数: " + pool.getPoolSize()); // 输出: 5
 
        // 等待 70 秒, 超过 keepAliveTime(60s)
        Thread.sleep(70_000);
        // 所有线程空闲超过 60 秒, 已被回收
        System.out.println("70秒后线程数: " + pool.getPoolSize()); // 输出: 0
 
        pool.shutdown(); // 关闭线程池
    }
}

// ThreadPoolExecutor.execute() 中的关键逻辑(简化版)
public void execute(Runnable command) {
    int c = ctl.get();                            // 获取当前线程池状态和线程计数
 
    // Step 1: 核心线程创建 —— corePoolSize=0, 此条件永远为 false
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true)) return;     // 创建核心线程(不会走到这里)
    }
 
    // Step 2: 尝试入队 —— SynchronousQueue, 无空闲线程时 offer() 返回 false
    if (isRunning(c) && workQueue.offer(command)) {
        // 入队成功, 说明有空闲线程正在 poll() 等待, 任务直接移交
        // ...
    }
    // Step 3: 入队失败, 创建非核心线程 —— maximumPoolSize=MAX_VALUE, 几乎不会失败
    else if (!addWorker(command, false)) {
        // Step 4: 创建也失败了, 触发拒绝策略(实际上几乎不可能走到这里)
        reject(command);
    }
}

// SynchronousQueue 的行为演示
public class SynchronousQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个同步移交队列
        SynchronousQueue<String> queue = new SynchronousQueue<>();
 
        // 消费者线程: 在队列上阻塞等待
        new Thread(() -> {
            try {
                System.out.println("消费者: 等待数据...");
                String data = queue.take();            // 阻塞, 直到生产者 put
                System.out.println("消费者: 收到 " + data);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();     // 恢复中断标志
            }
        }, "Consumer").start();
 
        Thread.sleep(1000); // 确保消费者先就位
 
        // 生产者: 向队列中放入数据
        System.out.println("生产者: 发送数据...");
        queue.put("Hello");                            // 立即成功, 因为消费者已在等待
        System.out.println("生产者: 发送完毕");
 
        // 非阻塞尝试: 此时无消费者等待
        boolean success = queue.offer("World");        // 立即返回 false
        System.out.println("offer结果: " + success);  // 输出: false
    }
}

// 线程数爆炸导致 OOM 的演示 (危险代码, 仅供学习!)
public class CachedPoolOOMDemo {
    public static void main(String[] args) {
        // 创建缓存线程池
        ExecutorService pool = Executors.newCachedThreadPool();
 
        // 模拟高并发场景: 疯狂提交长耗时任务
        for (int i = 0; i < 100_000; i++) {
            final int taskId = i;                    // 任务编号
            pool.execute(() -> {
                System.out.println("Task-" + taskId  // 打印任务信息
                    + " on " + Thread.currentThread().getName());
                try {
                    Thread.sleep(Long.MAX_VALUE);    // 模拟永不结束的任务
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 恢复中断标志
                }
            });
        }
        // 最终抛出: java.lang.OutOfMemoryError: unable to create new native thread
    }
}

// 场景还原: 下游服务变慢导致线程爆炸
//
// 正常情况:
//   QPS = 100, 响应时间 = 50ms
//   所需线程 ≈ 100 * 0.05 = 5 个 (Little's Law)
//   CachedThreadPool 轻松应对, 只维护 5~10 个线程
//
// 异常情况(数据库慢查询):
//   QPS = 100, 响应时间 = 30s
//   所需线程 ≈ 100 * 30 = 3000 个!
//   第 1 秒: 创建 100 个线程
//   第 2 秒: 再创建 100 个 (之前的还没执行完)
//   第 30 秒: 已累计创建 3000 个线程
//   如果持续 60 秒: 6000 个线程, 占用 ~6GB 栈内存
//   → OutOfMemoryError: unable to create new native thread
//   → 整个 JVM 进程崩溃

// 安全的替代方案: 手动创建线程池, 限制最大线程数和队列容量
ThreadPoolExecutor safePool = new ThreadPoolExecutor(
    10,                                    // corePoolSize: 10 个核心线程
    50,                                    // maximumPoolSize: 最多 50 个线程(而非 MAX_VALUE)
    60L,                                   // keepAliveTime: 非核心线程空闲 60 秒回收
    TimeUnit.SECONDS,                      // 时间单位
    new LinkedBlockingQueue<>(200),        // 有界队列, 最多缓存 200 个任务(而非无界)
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略: 由提交线程自己执行, 起到限流效果
);
// 最大并发承载: 50 个线程正在执行 + 200 个任务在队列中排队 = 250 个任务
// 超过 250 个: 由调用者线程执行, 自然降低提交速率(背压机制)

// Executors 工厂方法源码（JDK）
public static ExecutorService newSingleThreadExecutor() {
    // 外层用 FinalizableDelegatedExecutorService 包装
    // 目的是：屏蔽 ThreadPoolExecutor 的配置方法，防止外部修改核心参数
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(
            1,                              // corePoolSize = 1，核心线程数为1
            1,                              // maximumPoolSize = 1，最大线程数也为1
            0L,                             // keepAliveTime = 0，无空闲回收（只有核心线程）
            TimeUnit.MILLISECONDS,          // 时间单位（实际不生效，因为 keepAlive=0）
            new LinkedBlockingQueue<Runnable>()  // 无界阻塞队列
        )
    );
}

// FixedThreadPool(1) —— 返回的是 ThreadPoolExecutor 本身
ExecutorService fixed = Executors.newFixedThreadPool(1);
 
// 可以被强转！从而修改线程数，破坏"单线程"的语义
((ThreadPoolExecutor) fixed).setCorePoolSize(5);    // 成功！变成了5个线程
((ThreadPoolExecutor) fixed).setMaximumPoolSize(10); // 成功！
 
// SingleThreadExecutor —— 返回的是 DelegatedExecutorService 的包装
ExecutorService single = Executors.newSingleThreadExecutor();
 
// 尝试强转会抛出 ClassCastException
// ((ThreadPoolExecutor) single).setCorePoolSize(5);  // 编译通过，运行报错！

// 演示异常后线程自动重建
ExecutorService single = Executors.newSingleThreadExecutor();
 
// 第一个任务：故意抛出异常
single.execute(() -> {
    // 打印当前线程名，观察线程身份
    System.out.println("Task 1 running on: " + Thread.currentThread().getName());
    // 抛出运行时异常，导致当前工作线程死亡
    throw new RuntimeException("Boom!");
});
 
// 短暂等待，确保第一个任务已经执行完毕（并崩溃）
Thread.sleep(100);
 
// 第二个任务：依然能正常执行
single.execute(() -> {
    // 注意观察：线程名可能变了（如从 pool-1-thread-1 变为 pool-1-thread-2）
    // 说明旧线程已死，新线程被创建
    System.out.println("Task 2 running on: " + Thread.currentThread().getName());
});
 
// 可能的输出：
// Task 1 running on: pool-1-thread-1
// Task 2 running on: pool-1-thread-2   <-- 新线程！

┌──────────────────────────────────────────────────┐
│            SingleThreadExecutor                  │
│                                                  │
│   ┌──────────┐     ┌──────────────────────────┐  │
│   │  Worker   │◄────│  LinkedBlockingQueue     │  │
│   │ (Thread)  │     │  (无界)                   │  │
│   │          │     │                          │  │
│   │ 一次只有  │     │  Task A ← Task B ← ...  │  │
│   │ 1个活跃   │     │  FIFO 先进先出            │  │
│   └──────────┘     └──────────────────────────┘  │
│        │                                         │
│        ▼                                         │
│   线程崩溃？ ──Yes──► 自动创建新 Worker            │
│        │                                         │
│       No                                         │
│        ▼                                         │
│   继续从队列取下一个任务                            │
└──────────────────────────────────────────────────┘

// 演示：任务之间的内存可见性
// 注意：sharedState 没有用 volatile 修饰！
// 在普通多线程场景下，这可能导致可见性问题
// 但在 SingleThreadExecutor 中是安全的
int[] sharedState = {0};  // 共享状态（用数组是为了在 lambda 中可修改）
 
ExecutorService single = Executors.newSingleThreadExecutor();
 
// Task 1：修改共享状态
single.execute(() -> {
    sharedState[0] = 42;  // 写入
    System.out.println("Task 1: set sharedState = 42");
});
 
// Task 2：读取共享状态
single.execute(() -> {
    // 由于 happens-before 保证，这里一定能看到 42
    System.out.println("Task 2: sharedState = " + sharedState[0]);  // 保证输出 42
});
 
// Task 3：继续基于前序任务的结果操作
single.execute(() -> {
    sharedState[0] += 8;  // 基于 Task 1 的结果累加
    System.out.println("Task 3: sharedState = " + sharedState[0]);  // 保证输出 50
});

public class OrderedLogger {
    // 创建单线程执行器专门负责写日志
    private final ExecutorService logExecutor = Executors.newSingleThreadExecutor();
    
    // 异步写日志：调用方不阻塞，日志按提交顺序写入
    public void log(String message) {
        logExecutor.execute(() -> {
            // 这里的所有 I/O 操作都在同一个线程中串行执行
            // 不会出现日志交错（interleaved output）的问题
            String timestamp = LocalDateTime.now().toString();  // 获取时间戳
            System.out.println("[" + timestamp + "] " + message); // 写出日志
        });
    }
    
    // 关闭日志系统时，确保所有待写日志都完成
    public void shutdown() {
        logExecutor.shutdown();  // 不再接受新任务，等待已提交任务执行完毕
    }
}

// 模拟一个简化版的 UI 事件队列
ExecutorService uiThread = Executors.newSingleThreadExecutor(r -> {
    Thread t = new Thread(r, "UI-Thread");  // 给线程命名，便于调试
    t.setDaemon(true);                       // 设为守护线程，主线程退出时自动结束
    return t;
});
 
// 所有 UI 操作都提交到这个单线程池
uiThread.execute(() -> updateLabel("Loading..."));   // 第1步：显示加载
uiThread.execute(() -> updateProgressBar(50));        // 第2步：更新进度
uiThread.execute(() -> updateLabel("Done!"));         // 第3步：显示完成
// 保证 UI 操作严格按 1→2→3 顺序执行，不会出现"Done!"显示后进度条才到50%的情况

ExecutorService dbExecutor = Executors.newSingleThreadExecutor();
 
// 提交一系列必须有序执行的数据库操作
Future<?> step1 = dbExecutor.submit(() -> {
    // INSERT INTO users (name) VALUES ('Alice')
    userDao.insert(new User("Alice"));        // 第一步：插入
});
 
Future<?> step2 = dbExecutor.submit(() -> {
    // UPDATE users SET age = 30 WHERE name = 'Alice'
    userDao.updateAge("Alice", 30);           // 第二步：更新（依赖第一步的INSERT）
});
 
Future<User> step3 = dbExecutor.submit(() -> {
    // SELECT * FROM users WHERE name = 'Alice'
    return userDao.findByName("Alice");       // 第三步：查询（能看到前两步的结果）
});
 
// step3.get() 保证能拿到 name=Alice, age=30 的完整数据
User alice = step3.get();

// 推荐：手动创建安全的"单线程池"
ExecutorService safeSingle = new ThreadPoolExecutor(
    1,                                  // corePoolSize = 1
    1,                                  // maximumPoolSize = 1
    0L, TimeUnit.MILLISECONDS,          // keepAliveTime = 0
    new LinkedBlockingQueue<>(1000),     // 有界队列！最多积压1000个任务
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略：让提交者自己执行，起到限流效果
);

// ScheduledThreadPoolExecutor 的核心构造方法
public ScheduledThreadPoolExecutor(int corePoolSize) {
    // 调用父类 ThreadPoolExecutor 的构造方法
    // corePoolSize: 核心线程数，由用户指定
    // Integer.MAX_VALUE: 最大线程数，理论上无上限
    // DEFAULT_KEEPALIVE_MILLIS: 非核心线程的存活时间（10毫秒）
    // NANOSECONDS: 时间单位为纳秒
    // new DelayedWorkQueue(): 使用专用的延迟工作队列
    super(corePoolSize, Integer.MAX_VALUE,
          DEFAULT_KEEPALIVE_MILLIS, NANOSECONDS,
          new DelayedWorkQueue());
}

// 创建一个拥有 2 个核心线程的调度线程池
ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(2);
 
// ========== 1. 提交一个 Runnable 类型的延迟任务 ==========
// 含义：延迟 3 秒后执行，没有返回值
ScheduledFuture<?> future1 = scheduler.schedule(
    () -> {
        // 这段代码将在 3 秒后被某个线程执行
        System.out.println("Task executed after 3s delay, thread: "
            + Thread.currentThread().getName());
    },
    3,                  // delay: 延迟时长
    TimeUnit.SECONDS    // unit: 时间单位
);
 
// ========== 2. 提交一个 Callable 类型的延迟任务 ==========
// 含义：延迟 5 秒后执行，并返回计算结果
ScheduledFuture<String> future2 = scheduler.schedule(
    () -> {
        // 这段代码将在 5 秒后被执行，并返回字符串结果
        return "Computation finished at " + System.currentTimeMillis();
    },
    5,                  // delay: 延迟时长
    TimeUnit.SECONDS    // unit: 时间单位
);
 
// 阻塞获取 Callable 任务的结果
// get() 会等到任务执行完毕才返回
String result = future2.get();
System.out.println(result);

ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(2);
 
// scheduleAtFixedRate: 以固定的速率（频率）执行任务
// initialDelay = 1秒: 首次执行在提交后 1 秒
// period = 3秒: 每次执行的【开始时间】间隔 3 秒
scheduler.scheduleAtFixedRate(
    () -> {
        System.out.println("[FixedRate] start at " + System.currentTimeMillis());
        try {
            // 模拟任务执行耗时 1 秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("[FixedRate] end   at " + System.currentTimeMillis());
    },
    1,                  // initialDelay: 首次延迟 1 秒
    3,                  // period: 周期 3 秒
    TimeUnit.SECONDS    // unit: 时间单位
);

时间轴(秒)    0    1    2    3    4    5    6    7    8    9   10
              |    |=========|    .    |=========|    .    |=========|
                   ↑ 第1次开始         ↑ 第2次开始         ↑ 第3次开始
                   t=1               t=4               t=7
                   
间隔: t4 - t1 = 3s ✓    t7 - t4 = 3s ✓

时间轴(秒)    0    1    2    3    4    5    6    7    8    9   10   11
              |    |=================|=================|=================|
                   ↑ 第1次(1~6)      ↑ 第2次(6~11)     ↑ 第3次(11~16)
                   
实际间隔: 5s > 3s，所以结束后立即开始下一次，不存在并行执行

ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(2);
 
// scheduleWithFixedDelay: 以固定的延迟间隔执行任务
// initialDelay = 1秒: 首次执行在提交后 1 秒
// delay = 3秒: 上一次执行【结束】后，等待 3 秒再开始下一次
scheduler.scheduleWithFixedDelay(
    () -> {
        System.out.println("[FixedDelay] start at " + System.currentTimeMillis());
        try {
            // 模拟任务执行耗时 1 秒
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("[FixedDelay] end   at " + System.currentTimeMillis());
    },
    1,                  // initialDelay: 首次延迟 1 秒
    3,                  // delay: 固定延迟 3 秒
    TimeUnit.SECONDS    // unit: 时间单位
);

时间轴(秒)    0    1    2    3    4    5    6    7    8    9   10   11
              |    |===|    .    .    |===|    .    .    |===|
                   ↑第1次        3s空闲 ↑第2次        3s空闲 ↑第3次
                 (1~2)              (5~6)              (9~10)
 
实际间隔: (5-1)=4s = 执行1s + 空闲3s ✓

时间轴(秒)    0    1    2    3    4    5    6    7    8    9   10   11   12   13   14
              |    |=================|    .    .    |=================|
                   ↑ 第1次(1~6)       3s空闲        ↑ 第2次(9~14)
 
实际间隔: (9-1)=8s = 执行5s + 空闲3s ✓

// DelayedWorkQueue 的核心结构（简化版）
static class DelayedWorkQueue extends AbstractQueue<Runnable>
    implements BlockingQueue<Runnable> {
 
    // 底层数据结构：基于数组的最小堆（min-heap）
    // 堆顶元素始终是触发时间最早的任务
    private RunnableScheduledFuture<?>[] queue =
        new RunnableScheduledFuture<?>[16];  // 初始容量 16
 
    // 堆中当前元素数量
    private int size = 0;
 
    // 用于精确等待的 Leader-Follower 模式
    // leader 线程负责等待堆顶任务到期
    private Thread leader = null;
 
    // 所有线程共享的条件变量
    private final Condition available = lock.newCondition();
}

DelayedWorkQueue 内部堆结构示意 (min-heap by trigger time)：
 
               ┌──────────────┐
               │ Task-A (t=3) │  ← 堆顶: 最早触发的任务
               └──────┬───────┘
              ┌───────┴────────┐
       ┌──────┴──────┐  ┌──────┴──────┐
       │ Task-B (t=5)│  │ Task-C (t=7)│
       └──────┬──────┘  └──────┬──────┘
         ┌────┴────┐      ┌────┴────┐
    ┌────┴────┐ ┌──┴───┐ ┌┴──────┐  │
    │Task-D(9)│ │T-E(10│ │T-F(12)│  ...
    └─────────┘ └──────┘ └───────┘
    
    工作线程 take() → 取堆顶 Task-A → sift-down 重建堆

// ScheduledFutureTask.run() 的简化逻辑
public void run() {
    // 1. 判断是否为周期任务（period != 0 表示周期任务）
    boolean periodic = isPeriodic();
 
    // 2. 检查线程池当前状态是否还允许执行
    if (!canRunInCurrentRunState(periodic))
        cancel(false);  // 线程池已关闭，取消任务
 
    // 3a. 如果是一次性任务（schedule），直接执行
    else if (!periodic)
        ScheduledFutureTask.super.run();  // 调用 FutureTask.run()
 
    // 3b. 如果是周期任务，执行但不设置结果（不触发 Future 完成）
    else if (ScheduledFutureTask.super.runAndReset()) {
        // 4. 任务执行成功后，计算下一次触发时间
        setNextRunTime();
        // 5. 将自身重新放入 DelayedWorkQueue
        reExecutePeriodic(outerTask);
    }
}

// 计算下一次触发时间的逻辑
private void setNextRunTime() {
    long p = period;
    if (p > 0)
        // scheduleAtFixedRate: 下次时间 = 本次触发时间 + period
        // 注意：是基于「计划触发时间」而非「实际结束时间」
        time += p;
    else
        // scheduleWithFixedDelay: 下次时间 = 当前时刻(now) + |delay|
        // period 为负数表示 FixedDelay 模式
        time = triggerTime(-p);
}

ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(1);
 
// 这个任务将在第 3 次执行时抛出异常
scheduler.scheduleAtFixedRate(() -> {
    // 假设 counter 是某个递增计数器
    int count = counter.incrementAndGet();
    System.out.println("Execution #" + count);
 
    if (count == 3) {
        // 第 3 次执行抛出异常
        throw new RuntimeException("Boom!");
        // 从此之后，这个任务彻底消失
        // 没有日志、没有通知、没有 stacktrace
    }
}, 0, 1, TimeUnit.SECONDS);
 
// 输出:
// Execution #1
// Execution #2
// Execution #3
// （然后永久静默，再也不会执行）

scheduler.scheduleAtFixedRate(() -> {
    try {
        // ======== 业务逻辑开始 ========
        riskyBusinessLogic();
        // ======== 业务逻辑结束 ========
    } catch (Exception e) {
        // 捕获所有异常，记录日志，但不让异常逃逸
        // 这样 runAndReset() 返回 true，周期调度继续
        log.error("Scheduled task failed, but will retry next period", e);
    }
}, 0, 1, TimeUnit.SECONDS);

ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(4);
 
// 控制 shutdown() 后是否继续执行已提交的「周期任务」
// 默认 false: shutdown 后周期任务停止
scheduler.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
 
// 控制 shutdown() 后是否继续执行已提交的「延迟一次性任务」
// 默认 true: shutdown 后延迟任务仍会执行
scheduler.setExecuteExistingDelayedTasksAfterShutdownPolicy(true);
 
// 当任务被取消时，是否立即从队列中移除（而非等到触发时才懒删除）
// 默认 false，建议设为 true 以避免大量已取消任务堆积占用内存
scheduler.setRemoveOnCancelPolicy(true);

// ========== 生产环境推荐的 ScheduledThreadPoolExecutor 创建方式 ==========
ScheduledThreadPoolExecutor scheduler = new ScheduledThreadPoolExecutor(
    // 核心线程数：根据定时任务数量和执行耗时合理评估
    // 一般 2~4 个线程足以覆盖大多数场景
    Runtime.getRuntime().availableProcessors(),
 
    // 使用自定义 ThreadFactory 命名线程，便于排查问题
    new ThreadFactory() {
        private final AtomicInteger counter = new AtomicInteger(0);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            // 给线程起有意义的名字，出问题时 jstack 一看便知
            t.setName("biz-scheduler-" + counter.incrementAndGet());
            // 设为守护线程，随 JVM 退出
            t.setDaemon(true);
            return t;
        }
    },
 
    // 拒绝策略：对于定时任务，通常选择丢弃或记录日志
    new ThreadPoolExecutor.CallerRunsPolicy()
);
 
// 推荐：取消任务时立即从队列移除，避免内存泄漏
scheduler.setRemoveOnCancelPolicy(true);

scheduler.scheduleAtFixedRate(() -> {
    try { Thread.sleep(4000); } catch (Exception e) {}
}, 0, 2, TimeUnit.SECONDS);

// java.util.concurrent.Executors 源码
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(
        nThreads,                          // corePoolSize: 核心线程数
        nThreads,                          // maximumPoolSize: 最大线程数（与核心相同）
        0L, TimeUnit.MILLISECONDS,         // keepAliveTime: 0，核心线程不回收
        new LinkedBlockingQueue<Runnable>() // ⚠️ 关键！无参构造 → 容量为 Integer.MAX_VALUE
    );
}

// java.util.concurrent.LinkedBlockingQueue 源码
public LinkedBlockingQueue() {
    // capacity 被设置为 Integer.MAX_VALUE = 2,147,483,647
    // 约 21 亿，在实际意义上等同于"无界"
    this(Integer.MAX_VALUE);
}

// 一个典型的生产事故代码
public class OrderService {
 
    // 创建一个固定 10 个线程的线程池
    private static final ExecutorService pool = Executors.newFixedThreadPool(10);
 
    // 处理订单的方法，每次 HTTP 请求调用一次
    public void processOrder(Order order) {
        // 将订单处理任务提交到线程池
        pool.submit(() -> {
            // 假设这里需要调用下游服务，平均耗时 2 秒
            callDownstreamService(order);  // 网络 IO，响应缓慢
            saveToDatabase(order);          // 数据库写入
            sendNotification(order);        // 发送通知
        });
        // submit() 永远不会阻塞，永远不会抛出 RejectedExecutionException
        // 因为队列几乎无限大，任务总是能入队"成功"
    }
}

// java.util.concurrent.Executors 源码
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService(
        new ThreadPoolExecutor(
            1, 1,                              // 只有 1 个线程
            0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>() // ⚠️ 同样是无界队列
        )
    );
}

// java.util.concurrent.Executors 源码
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(
        0,                                  // corePoolSize: 0，没有核心线程
        Integer.MAX_VALUE,                  // ⚠️ maximumPoolSize: 约 21 亿
        60L, TimeUnit.SECONDS,              // 空闲 60 秒后回收
        new SynchronousQueue<Runnable>()    // 不存储任务，直接交给线程
    );
}

// 模拟 CachedThreadPool 的线程爆炸
public class CachedPoolOOMDemo {
    public static void main(String[] args) {
        // 创建 CachedThreadPool
        ExecutorService pool = Executors.newCachedThreadPool();
 
        // 模拟突发高并发场景
        for (int i = 0; i < 100_000; i++) {
            pool.submit(() -> {
                try {
                    // 模拟耗时任务：每个任务执行 10 秒
                    Thread.sleep(10_000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
            // 每次循环，由于之前的线程都在 sleep，没有空闲线程
            // SynchronousQueue 无法交付 → 线程池创建新线程
            // 结果：直接创建了 100,000 个线程！
        }
    }
}

100,000 个线程 × 1MB/线程 ≈ 100GB 内存
 
远远超出任何服务器的物理内存限制

java.lang.OutOfMemoryError: unable to create new native thread

// ┌─────────────────────────────────────────────────────────────────────┐
// │              两种 OOM 路径对比                                       │
// ├──────────────────┬──────────────────┬───────────────────────────────┤
// │      维度         │   队列无界 OOM    │      线程数无界 OOM            │
// ├──────────────────┼──────────────────┼───────────────────────────────┤
// │  涉及线程池       │ Fixed / Single   │      Cached                   │
// │  问题队列         │ LinkedBlocking   │      SynchronousQueue         │
// │                  │ Queue(MAX)       │      (容量 0, 不存储)          │
// │  内存消耗来源     │ 堆中的任务对象     │      线程栈(native memory)     │
// │  错误信息         │ Java heap space  │      unable to create native  │
// │                  │                  │      thread                   │
// │  恶化速度         │ 较慢(静默堆积)    │      极快(线程瞬间爆炸)         │
// │  可监控性         │ 低(无异常抛出)    │      低(无异常抛出)             │
// │  是否可恢复       │ 困难             │      几乎不可能                 │
// └──────────────────┴──────────────────┴───────────────────────────────┘

// ThreadPoolExecutor 完整构造函数（7 个参数）
public ThreadPoolExecutor(
    int corePoolSize,                   // 核心线程数：常驻线程，不会被回收
    int maximumPoolSize,                // 最大线程数：线程池能创建的线程上限
    long keepAliveTime,                 // 空闲存活时间：非核心线程空闲超过该时长后被回收
    TimeUnit unit,                      // 时间单位：keepAliveTime 的单位
    BlockingQueue<Runnable> workQueue,  // 工作队列：存放等待执行的任务
    ThreadFactory threadFactory,        // 线程工厂：自定义线程创建方式（命名、优先级等）
    RejectedExecutionHandler handler    // 拒绝策略：队列满且线程数达到上限时的处理策略
) { ... }

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
 
public class ThreadPoolFactory {
 
    /**
     * 创建一个生产级的线程池
     * 
     * @param bizName 业务名称，用于线程命名，方便排查问题
     * @return 配置完善的线程池
     */
    public static ThreadPoolExecutor createBizPool(String bizName) {
 
        // 获取可用 CPU 核心数
        int cpuCores = Runtime.getRuntime().availableProcessors();
 
        // 1. 核心线程数：CPU 核心数（适合 CPU 密集型任务）
        //    如果是 IO 密集型，可以设为 2 * cpuCores
        int coreSize = cpuCores;
 
        // 2. 最大线程数：核心线程数的 2 倍，设定明确上限
        //    绝不使用 Integer.MAX_VALUE！
        int maxSize = cpuCores * 2;
 
        // 3. 空闲线程存活时间：60 秒
        long keepAlive = 60L;
 
        // 4. 工作队列：使用有界队列！容量根据业务评估设定
        //    这里设为 1024，超过此容量将触发拒绝策略
        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(1024);
 
        // 5. 自定义线程工厂：给线程起一个有意义的名字
        //    在排查线程 dump 时，"order-pool-thread-3" 比 "pool-1-thread-3" 有用得多
        ThreadFactory factory = new ThreadFactory() {
            // 线程编号计数器，保证线程安全
            private final AtomicInteger counter = new AtomicInteger(1);
 
            @Override
            public Thread newThread(Runnable r) {
                // 线程命名格式：业务名-pool-thread-编号
                Thread t = new Thread(r, bizName + "-pool-thread-" + counter.getAndIncrement());
                // 设为非守护线程，确保任务执行完毕
                t.setDaemon(false);
                // 设置普通优先级
                t.setPriority(Thread.NORM_PRIORITY);
                return t;
            }
        };
 
        // 6. 拒绝策略：CallerRunsPolicy——由调用线程自己执行该任务
        //    这样做的好处：不会丢弃任务，同时反压（backpressure）调用方，降低提交速率
        RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();
 
        // 7. 组装线程池：每一个参数都是经过深思熟虑的
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            coreSize,      // 核心线程数
            maxSize,        // 最大线程数
            keepAlive,      // 空闲存活时间
            TimeUnit.SECONDS, // 时间单位
            queue,          // 有界工作队列
            factory,        // 自定义线程工厂
            handler         // 拒绝策略
        );
 
        // 可选优化：允许核心线程超时回收（在低流量时释放资源）
        // executor.allowCoreThreadTimeOut(true);
 
        return executor;
    }
}

public class OrderService {
 
    // 使用手动创建的线程池，参数可控、命名清晰
    private static final ThreadPoolExecutor orderPool =
        ThreadPoolFactory.createBizPool("order");
 
    public void processOrder(Order order) {
        orderPool.submit(() -> {
            callDownstreamService(order);
            saveToDatabase(order);
            sendNotification(order);
        });
        // 如果队列已满且线程数达到上限：
        // CallerRunsPolicy 会让当前调用线程（如 Tomcat 线程）自己执行任务
        // 效果：自动限流，而非 OOM
    }
}

// ┌──────────────────────────┬─────────────────────────────────────────────────┐
// │         策略名称          │                   行为描述                       │
// ├──────────────────────────┼─────────────────────────────────────────────────┤
// │ AbortPolicy (默认)       │ 直接抛出 RejectedExecutionException             │
// │                          │ 适合：对任务丢失零容忍，需要上层显式处理异常        │
// ├──────────────────────────┼─────────────────────────────────────────────────┤
// │ CallerRunsPolicy ⭐推荐  │ 由提交任务的线程自己执行该任务                     │
// │                          │ 适合：不想丢任务，且希望自动反压（backpressure）    │
// │                          │ 效果：提交方被阻塞，天然降低了任务提交速率          │
// ├──────────────────────────┼─────────────────────────────────────────────────┤
// │ DiscardPolicy            │ 静默丢弃新任务，不抛异常、不做任何事               │
// │                          │ 适合：可以容忍任务丢失的场景（如日志采集）          │
// │                          │ 注意：危险！问题被吞没，排查困难                   │
// ├──────────────────────────┼─────────────────────────────────────────────────┤
// │ DiscardOldestPolicy      │ 丢弃队列中最早的任务，然后重试提交新任务            │
// │                          │ 适合：新数据比旧数据重要的场景（如实时行情推送）     │
// └──────────────────────────┴─────────────────────────────────────────────────┘

// 自定义拒绝策略：将被拒绝的任务发送到消息队列
public class MqFallbackPolicy implements RejectedExecutionHandler {
 
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 记录告警日志
        log.warn("线程池 [{}] 任务被拒绝，转发至 MQ 降级处理", executor);
        // 将任务序列化后发送到消息队列（如 RocketMQ / Kafka）
        mqProducer.send("rejected-task-topic", serialize(r));
    }
}

private ExecutorService pool = Executors.newFixedThreadPool(20);

// 获取当前机器的可用处理器数量（逻辑核心数，含超线程）
int cpuCores = Runtime.getRuntime().availableProcessors();
// 例如：8核16线程的CPU，返回值为16

// CPU密集型线程池配置示例
public class CpuIntensivePoolExample {
    public static void main(String[] args) {
        // 1. 获取逻辑核心数
        int cpuCores = Runtime.getRuntime().availableProcessors();
 
        // 2. 核心线程数 = 逻辑核心数 + 1
        int poolSize = cpuCores + 1;
 
        // 3. 创建线程池：核心与最大线程数相同，使用有界队列
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            poolSize,                               // 核心线程数：N+1
            poolSize,                               // 最大线程数：与核心相同，无需弹性扩展
            0L,                                     // 空闲时间：核心线程不回收，此值无意义
            TimeUnit.MILLISECONDS,                  // 时间单位
            new ArrayBlockingQueue<>(256),           // 有界阻塞队列，防止OOM
            new ThreadFactory() {                   // 自定义线程工厂，便于排查问题
                private final AtomicInteger counter = new AtomicInteger(1);
                @Override
                public Thread newThread(Runnable r) {
                    // 给线程起一个有业务含义的名字
                    return new Thread(r, "cpu-pool-thread-" + counter.getAndIncrement());
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略：调用者自己执行，起到限流作用
        );
 
        // 4. 提交CPU密集型任务（示例：计算斐波那契数列）
        for (int i = 0; i < 100; i++) {
            final int n = i;
            executor.submit(() -> {
                // 纯计算任务，几乎不涉及IO
                long result = fibonacci(40);
                System.out.println("Task-" + n + " result: " + result);
            });
        }
 
        // 5. 优雅关闭线程池
        executor.shutdown();
    }
 
    // 纯CPU密集运算：递归计算斐波那契（仅做示例，实际不推荐递归）
    private static long fibonacci(int n) {
        if (n <= 1) return n;              // 递归基
        return fibonacci(n - 1) + fibonacci(n - 2); // 大量CPU运算
    }
}

// IO密集型线程池配置示例
public class IoIntensivePoolExample {
    public static void main(String[] args) {
        // 1. 获取逻辑核心数
        int cpuCores = Runtime.getRuntime().availableProcessors();
 
        // 2. IO密集型：线程数 = 2 * 逻辑核心数
        int poolSize = cpuCores * 2;
 
        // 3. 创建线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            poolSize,                               // 核心线程数：2N
            poolSize,                               // 最大线程数：与核心相同
            60L,                                    // 空闲存活时间：60秒
            TimeUnit.SECONDS,                       // 时间单位
            new LinkedBlockingQueue<>(1024),         // 有界队列，容量适当放大（IO任务处理快）
            new ThreadFactory() {                   // 自定义线程工厂
                private final AtomicInteger counter = new AtomicInteger(1);
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "io-pool-thread-" + counter.getAndIncrement());
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
        );
 
        // 4. 提交IO密集型任务（示例：模拟HTTP请求）
        for (int i = 0; i < 500; i++) {
            final int taskId = i;
            executor.submit(() -> {
                try {
                    // 模拟一次远程HTTP调用，耗时200ms（绝大部分是IO等待）
                    System.out.println(Thread.currentThread().getName()
                        + " 开始请求 Task-" + taskId);
                    Thread.sleep(200);  // 模拟IO等待
                    System.out.println(Thread.currentThread().getName()
                        + " 完成请求 Task-" + taskId);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 恢复中断标志
                }
            });
        }
 
        // 5. 优雅关闭
        executor.shutdown();
    }
}

public class TaskProfiler {
    
    // 模拟一个混合型任务：部分计算 + 部分IO
    public void mixedTask() {
        // ---------- 计算阶段：记录CPU耗时 ----------
        long computeStart = System.nanoTime();       // 记录计算开始时间
        
        // 模拟CPU计算（如JSON解析、数据转换、业务规则校验）
        double result = 0;
        for (int i = 0; i < 1_000_000; i++) {
            result += Math.sin(i) * Math.cos(i);     // 纯CPU运算
        }
        
        long computeEnd = System.nanoTime();          // 记录计算结束时间
        long computeTime = computeEnd - computeStart; // 计算耗时（纳秒）
        
        // ---------- IO阶段：记录IO等待耗时 ----------
        long waitStart = System.nanoTime();           // 记录IO开始时间
        
        // 模拟数据库查询或HTTP请求
        try {
            Thread.sleep(100);  // 假设IO等待100ms
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        long waitEnd = System.nanoTime();             // 记录IO结束时间
        long waitTime = waitEnd - waitStart;          // IO等待耗时（纳秒）
        
        // ---------- 计算最优线程数 ----------
        int cpuCores = Runtime.getRuntime().availableProcessors();
        double targetUtilization = 0.8;               // 目标CPU利用率80%
        double ratio = (double) waitTime / computeTime; // W/C比率
        
        // 应用公式：N = Ncpu * Ucpu * (1 + W/C)
        int optimalThreads = (int) Math.ceil(
            cpuCores * targetUtilization * (1 + ratio)
        );
        
        // 打印分析结果
        System.out.println("CPU核心数: " + cpuCores);
        System.out.println("计算耗时(ms): " + computeTime / 1_000_000);
        System.out.println("IO等待耗时(ms): " + waitTime / 1_000_000);
        System.out.println("W/C比率: " + String.format("%.2f", ratio));
        System.out.println("建议线程数: " + optimalThreads);
    }
}