线程池基础 ⭐⭐

// ❌ 反面示例：为每个任务都创建一个新线程
public class NaiveServer {
    public static void main(String[] args) {
        // 模拟一个简单的服务器，持续接收任务
        while (true) {
            // 获取一个新的任务请求（此处用 Runnable 模拟）
            Runnable task = getNextTask();
 
            // 每次都 new Thread —— 这是性能杀手！
            // 1. 线程创建需要分配栈内存（默认 ~1MB）
            // 2. 需要操作系统内核调用（用户态 → 内核态切换）
            // 3. 任务执行完毕后线程被销毁，下次还要重建
            new Thread(task).start();
        }
    }
 
    private static Runnable getNextTask() {
        // 模拟获取任务
        return () -> System.out.println(Thread.currentThread().getName() + " running");
    }
}

┌─────────────────── 裸线程模型 (10000 个请求) ───────────────────┐
│                                                                  │
│  Task-1 → [创建 Thread-1 (1MB)] → 执行 → [销毁 Thread-1]        │
│  Task-2 → [创建 Thread-2 (1MB)] → 执行 → [销毁 Thread-2]        │
│  Task-3 → [创建 Thread-3 (1MB)] → 执行 → [销毁 Thread-3]        │
│  ...                                                             │
│  Task-10000 → [创建 Thread-10000 (1MB)] → 执行 → [销毁]         │
│                                                                  │
│  峰值线程数: 10000      峰值内存占用: ~10 GB (仅线程栈)          │
│  创建/销毁操作: 20000 次内核调用                                  │
└──────────────────────────────────────────────────────────────────┘
 
┌─────────────────── 线程池模型 (10000 个请求) ───────────────────┐
│                                                                  │
│  Pool [Thread-1, Thread-2, ..., Thread-10]  ← 固定 10 个线程     │
│                                                                  │
│  Task-1    → Thread-1 领取 → 执行完毕 → Thread-1 归还池中        │
│  Task-2    → Thread-2 领取 → 执行完毕 → Thread-2 归还池中        │
│  ...                                                             │
│  Task-11   → Thread-1 再次领取 → 执行 → 归还  (线程被复用!)      │
│  ...                                                             │
│  Task-10000 → 某个空闲线程领取 → 执行 → 归还                     │
│                                                                  │
│  峰值线程数: 10           峰值内存占用: ~10 MB (仅线程栈)        │
│  创建/销毁操作: 仅 10 次 (初始化时)                               │
└──────────────────────────────────────────────────────────────────┘

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
public class ThreadCostComparison {
 
    // 总任务数量
    private static final int TASK_COUNT = 10_000;
 
    public static void main(String[] args) throws InterruptedException {
        // ========== 方式一：裸线程，每个任务一个新线程 ==========
        long startRaw = System.nanoTime(); // 记录开始时间（纳秒精度）
 
        Thread[] threads = new Thread[TASK_COUNT]; // 存放所有线程引用
        for (int i = 0; i < TASK_COUNT; i++) {
            // 为每个任务创建一个全新的线程
            threads[i] = new Thread(() -> {
                // 模拟一个极轻量级的任务（几乎不耗时）
                int sum = 0;
                for (int j = 0; j < 100; j++) {
                    sum += j; // 简单累加
                }
            });
            threads[i].start(); // 启动线程（触发内核调用）
        }
        // 等待所有线程执行完毕
        for (Thread t : threads) {
            t.join(); // 阻塞主线程直到 t 执行完成
        }
 
        long durationRaw = System.nanoTime() - startRaw; // 计算耗时
        System.out.println("裸线程模型耗时: " + TimeUnit.NANOSECONDS.toMillis(durationRaw) + " ms");
 
        // ========== 方式二：线程池，复用固定数量的线程 ==========
        // 创建一个拥有 10 个核心线程的固定线程池
        ExecutorService pool = Executors.newFixedThreadPool(10);
 
        long startPool = System.nanoTime(); // 记录开始时间
 
        for (int i = 0; i < TASK_COUNT; i++) {
            // 将任务提交给线程池，由池内线程调度执行
            pool.submit(() -> {
                int sum = 0;
                for (int j = 0; j < 100; j++) {
                    sum += j; // 同样的轻量任务
                }
            });
        }
 
        pool.shutdown(); // 不再接受新任务，等待已提交的任务完成
        pool.awaitTermination(1, TimeUnit.MINUTES); // 最多等待 1 分钟
 
        long durationPool = System.nanoTime() - startPool; // 计算耗时
        System.out.println("线程池模型耗时: " + TimeUnit.NANOSECONDS.toMillis(durationPool) + " ms");
 
        // 典型输出（视机器配置不同而异）:
        // 裸线程模型耗时: 1200 ms
        // 线程池模型耗时: 45 ms
        // 线程池快了约 25~30 倍！
    }
}

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
 
public class PreStartDemo {
    public static void main(String[] args) {
        // 创建一个核心线程数为 4、最大线程数为 8 的线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                4,                              // corePoolSize: 核心线程数
                8,                              // maximumPoolSize: 最大线程数
                60L,                            // keepAliveTime: 非核心线程空闲存活时间
                TimeUnit.SECONDS,               // 时间单位：秒
                new LinkedBlockingQueue<>(100)   // 工作队列：容量 100
        );
 
        // 此时还没有提交任何任务
        System.out.println("提交任务前的线程数: " + executor.getPoolSize());
        // 输出: 0  —— 默认是懒加载，没有任务就不创建线程
 
        // 预启动所有核心线程（提前"热身"）
        int preStarted = executor.prestartAllCoreThreads();
        System.out.println("预启动了 " + preStarted + " 个核心线程");
        // 输出: 预启动了 4 个核心线程
 
        System.out.println("预启动后的线程数: " + executor.getPoolSize());
        // 输出: 4  —— 4 个核心线程已就绪，等待任务
 
        // 现在提交一个任务，会被立即执行，无需等待线程创建
        long before = System.nanoTime();
        executor.execute(() -> {
            long latency = System.nanoTime() - before; // 计算从提交到执行的延迟
            System.out.println("任务启动延迟: " + latency + " ns (~"
                    + TimeUnit.NANOSECONDS.toMicros(latency) + " μs)");
            // 典型输出: 任务启动延迟: ~5000 ns (~5 μs)
            // 对比裸线程: 通常在 50000~200000 ns (~50~200 μs)
        });
 
        // 关闭线程池
        executor.shutdown();
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.RejectedExecutionHandler;
 
public class ManagedPoolDemo {
    public static void main(String[] args) {
        // 通过 7 个参数精确控制线程池行为
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                4,                  // corePoolSize: 核心线程数（常驻线程）
                8,                  // maximumPoolSize: 最大线程数（绝对上限）
                30L,                // keepAliveTime: 非核心线程的空闲存活时间
                TimeUnit.SECONDS,   // 时间单位
                new ArrayBlockingQueue<>(200),  // 有界队列：最多缓冲 200 个任务
                new CustomThreadFactory(),      // 自定义线程工厂（见下方）
                new CustomRejectionPolicy()     // 自定义拒绝策略（见下方）
        );
 
        // 允许核心线程也可以超时回收（弹性伸缩）
        executor.allowCoreThreadTimeOut(true);
 
        // ========== 运行时监控 ==========
        // 线程池暴露了丰富的运行时指标，便于接入监控系统
        System.out.println("当前线程数:     " + executor.getPoolSize());
        System.out.println("活跃线程数:     " + executor.getActiveCount());
        System.out.println("已完成任务数:   " + executor.getCompletedTaskCount());
        System.out.println("队列中等待任务: " + executor.getQueue().size());
        System.out.println("历史最大线程数: " + executor.getLargestPoolSize());
 
        executor.shutdown(); // 优雅关闭
    }
}

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
 
public class CustomThreadFactory implements ThreadFactory {
 
    // 线程组名称前缀，用于区分不同业务模块
    private final String namePrefix;
 
    // 线程编号计数器（原子操作，线程安全）
    private final AtomicInteger threadNumber = new AtomicInteger(1);
 
    // 是否设置为守护线程
    private final boolean daemon;
 
    // 构造方法：指定线程名前缀
    public CustomThreadFactory() {
        this("order-pool", false); // 默认前缀和非守护线程
    }
 
    public CustomThreadFactory(String namePrefix, boolean daemon) {
        this.namePrefix = namePrefix; // 如 "order-pool", "payment-pool"
        this.daemon = daemon;
    }
 
    @Override
    public Thread newThread(Runnable r) {
        // 生成可读的线程名：如 "order-pool-worker-1", "order-pool-worker-2"
        String name = namePrefix + "-worker-" + threadNumber.getAndIncrement();
 
        Thread thread = new Thread(r, name); // 指定线程名
 
        thread.setDaemon(daemon); // 设置守护线程属性
 
        // 设置未捕获异常处理器 —— 防止线程"静默死亡"
        thread.setUncaughtExceptionHandler((t, e) -> {
            // 在生产环境中，这里应该接入日志框架（如 SLF4J + Logback）
            System.err.println("[ALERT] 线程 " + t.getName() + " 发生未捕获异常:");
            e.printStackTrace();
            // 还可以接入告警系统（钉钉、企业微信、PagerDuty 等）
        });
 
        return thread; // 返回配置好的线程实例
    }
}

"order-pool-worker-1" #15 prio=5 os_prio=0 tid=0x00007f... nid=0x4e03 waiting on condition
"order-pool-worker-2" #16 prio=5 os_prio=0 tid=0x00007f... nid=0x4e04 runnable
"payment-pool-worker-1" #17 prio=5 os_prio=0 tid=0x00007f... nid=0x4e05 waiting on condition

import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
 
public class CustomRejectionPolicy implements RejectedExecutionHandler {
 
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 策略：记录日志 + 降级处理，而不是默认的直接抛出异常
        System.err.println("[WARN] 任务被拒绝! 线程池状态 → "
                + "poolSize=" + executor.getPoolSize()           // 当前线程数
                + ", activeCount=" + executor.getActiveCount()   // 活跃线程数
                + ", queueSize=" + executor.getQueue().size()    // 队列中的任务数
                + ", completedTask=" + executor.getCompletedTaskCount()); // 已完成数
 
        // 生产环境的常见做法：
        // 1. 将任务持久化到数据库或消息队列，稍后重试
        // 2. 返回降级结果（如缓存数据、默认值）
        // 3. 记录指标（Metrics），触发扩容告警
 
        // 此处演示：如果线程池没有关闭，就让调用者线程自己执行（CallerRunsPolicy 的思路）
        if (!executor.isShutdown()) {
            System.out.println("[FALLBACK] 由调用者线程执行被拒绝的任务");
            r.run(); // 注意：这会阻塞调用者线程，起到天然的"限流"作用
        }
    }
}

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
 
public class GracefulShutdownDemo {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(4);
 
        // 提交一些任务
        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            pool.submit(() -> {
                try {
                    Thread.sleep(500); // 模拟耗时操作
                    System.out.println("Task-" + taskId + " 完成");
                } catch (InterruptedException e) {
                    // 线程被中断时的处理
                    System.out.println("Task-" + taskId + " 被中断");
                    Thread.currentThread().interrupt(); // 恢复中断标志
                }
            });
        }
 
        // ========== 优雅关闭的标准模板（推荐写法）==========
 
        pool.shutdown(); // 第一步：停止接受新任务，已提交的任务继续执行
        System.out.println("已调用 shutdown()，不再接受新任务");
 
        try {
            // 第二步：等待已提交的任务在规定时间内完成
            if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
                // 如果 10 秒内没有全部完成，强制关闭
                System.out.println("超时！正在强制关闭...");
                List<Runnable> abandoned = pool.shutdownNow(); // 返回未执行的任务列表
                System.out.println("被放弃的任务数: " + abandoned.size());
 
                // 再等待一小段时间，确保线程响应了中断
                if (!pool.awaitTermination(5, TimeUnit.SECONDS)) {
                    System.err.println("[ERROR] 线程池未能完全关闭!");
                }
            } else {
                System.out.println("所有任务已在超时前完成，优雅关闭成功");
            }
        } catch (InterruptedException e) {
            // 如果当前线程在等待过程中被中断，执行强制关闭
            pool.shutdownNow();
            Thread.currentThread().interrupt(); // 保留中断状态
        }
    }
}

// java.util.concurrent.Executor
// 整个线程池框架的根接口，只有一个职责：执行提交的任务
public interface Executor {
 
    // 在未来的某个时刻执行给定的命令（任务）
    // 该任务可能在新线程中执行、在线程池中执行、甚至在调用者线程中执行
    // 具体行为完全取决于实现类
    void execute(Runnable command);
}

// 传统方式：任务和线程创建强耦合
// 每次都手动创建新线程，完全没有复用
new Thread(new RunnableTask()).start();

// Executor 方式：只关心"做什么"，不关心"怎么做"
Executor executor = getSomeExecutor(); // 获取一个执行器实例
executor.execute(new RunnableTask());  // 提交任务，执行细节被隐藏

// 同步执行器：直接在调用者线程中运行任务
// 这是最简单的 Executor 实现，通常用于测试场景
class DirectExecutor implements Executor {
 
    @Override
    public void execute(Runnable command) {
        // 不创建新线程，直接在当前线程（调用者线程）中执行
        command.run();  // 注意是 run() 不是 start()
    }
}

// 异步执行器：为每个任务创建一个新线程
// 这种实现虽然简单，但存在线程爆炸的风险
class ThreadPerTaskExecutor implements Executor {
 
    @Override
    public void execute(Runnable command) {
        // 每次提交任务都创建一个全新的线程
        // 在高并发场景下会导致大量线程创建与销毁的开销
        new Thread(command).start();
    }
}

// 演示 submit() 的典型用法
// 创建一个固定大小为 3 的线程池
ExecutorService pool = Executors.newFixedThreadPool(3);
 
// 提交一个 Callable 任务（有返回值）
// Callable<String> 表示任务完成后返回 String 类型的结果
Future<String> future = pool.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // 模拟耗时计算
        Thread.sleep(2000);
        // 返回计算结果
        return "Task Completed";
    }
});
 
// 此时主线程可以去做其他事情...
System.out.println("主线程继续执行其他逻辑...");
 
try {
    // future.get() 会阻塞当前线程，直到任务完成并返回结果
    // 如果任务抛出异常，get() 会将其包装为 ExecutionException 抛出
    String result = future.get();
    System.out.println("任务结果: " + result);
} catch (InterruptedException e) {
    // 当前线程在等待过程中被中断
    Thread.currentThread().interrupt();
} catch (ExecutionException e) {
    // 任务执行过程中抛出了异常
    // e.getCause() 可以获取原始异常
    System.err.println("任务执行失败: " + e.getCause());
}

ExecutorService pool = Executors.newFixedThreadPool(5);
 
// 提交若干任务
for (int i = 0; i < 10; i++) {
    final int taskId = i;
    pool.submit(() -> {
        System.out.println("执行任务 " + taskId
                + " [线程: " + Thread.currentThread().getName() + "]");
        try {
            Thread.sleep(1000); // 模拟任务耗时
        } catch (InterruptedException e) {
            // shutdownNow() 会触发此中断
            System.out.println("任务 " + taskId + " 被中断");
            Thread.currentThread().interrupt(); // 恢复中断状态
        }
    });
}
 
// ===== 优雅关闭的标准模式（来自 Oracle 官方文档推荐） =====
 
pool.shutdown(); // 第一步：温和关闭，不再接受新任务
 
try {
    // 第二步：等待所有已提交的任务执行完毕，最多等 60 秒
    if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
        // 超时后仍未结束，进行强制关闭
        pool.shutdownNow(); // 第三步：强制关闭，中断正在执行的任务
 
        // 再次等待一段时间，确认线程池确实终止了
        if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
            System.err.println("线程池未能正常终止!");
        }
    }
} catch (InterruptedException e) {
    // 如果当前线程在等待过程中被中断，也进行强制关闭
    pool.shutdownNow();
    Thread.currentThread().interrupt(); // 保留中断状态
}

ExecutorService pool = Executors.newFixedThreadPool(3);
 
// 构建一组任务
List<Callable<String>> tasks = Arrays.asList(
    () -> { Thread.sleep(3000); return "结果A (慢)"; },  // 任务A，耗时3秒
    () -> { Thread.sleep(1000); return "结果B (快)"; },  // 任务B，耗时1秒
    () -> { Thread.sleep(2000); return "结果C (中)"; }   // 任务C，耗时2秒
);
 
// invokeAll：等待 所有任务 都完成后返回
// 返回的 Future 列表顺序与任务列表顺序一致
List<Future<String>> futures = pool.invokeAll(tasks);
for (Future<String> f : futures) {
    // 此时所有 Future 都已经完成，get() 不会阻塞
    System.out.println(f.get());
}
// 输出顺序固定：结果A -> 结果C -> 结果B？不！
// 是按提交顺序：结果A (慢) -> 结果B (快) -> 结果C (中)
 
// invokeAny：只要有 任意一个任务 完成就返回其结果
// 其余未完成的任务会被自动取消
String fastest = pool.invokeAny(tasks);
System.out.println("最快的结果: " + fastest); // 大概率输出 "结果B (快)"
 
pool.shutdown();

// ThreadPoolExecutor 最完整的构造函数
// 这 7 个参数决定了线程池的所有行为特征
public ThreadPoolExecutor(
    int corePoolSize,                          // 核心线程数
    int maximumPoolSize,                       // 最大线程数
    long keepAliveTime,                        // 非核心线程的空闲存活时间
    TimeUnit unit,                             // keepAliveTime 的时间单位
    BlockingQueue<Runnable> workQueue,         // 任务等待队列
    ThreadFactory threadFactory,               // 线程创建工厂
    RejectedExecutionHandler handler           // 拒绝策略
) { ... }

// 一个生产级别的 ThreadPoolExecutor 配置示例
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    // 核心线程数：通常设为 CPU 核心数（CPU 密集型）
    // 或 CPU 核心数 * 2（IO 密集型）
    // Runtime.getRuntime().availableProcessors() 获取 CPU 核心数
    4,                                          // corePoolSize
 
    // 最大线程数：核心线程 + 临时线程的总上限
    // 不宜设得过大，否则上下文切换开销剧增
    8,                                          // maximumPoolSize
 
    // 临时线程的空闲存活时间
    // 当线程空闲时间超过此值，且当前线程总数 > corePoolSize
    // 该线程会被回收销毁
    60L,                                        // keepAliveTime
 
    // keepAliveTime 的时间单位
    TimeUnit.SECONDS,                           // unit
 
    // 工作队列：存放等待执行的任务
    // ArrayBlockingQueue 是有界队列，容量为 100
    // 有界队列可以防止内存溢出（OOM）
    new ArrayBlockingQueue<>(100),              // workQueue
 
    // 线程工厂：自定义线程的创建方式
    // 最大的用途是给线程设置有意义的名称，方便排查问题
    new ThreadFactory() {
        // 使用 AtomicInteger 保证线程编号的原子性
        private final AtomicInteger counter = new AtomicInteger(1);
 
        @Override
        public Thread newThread(Runnable r) {
            // 创建新线程
            Thread t = new Thread(r);
            // 设置有意义的线程名称，格式：业务名-pool-thread-序号
            t.setName("order-pool-thread-" + counter.getAndIncrement());
            // 设置为非守护线程（默认也是，这里显式声明以强调意图）
            t.setDaemon(false);
            return t;
        }
    },                                          // threadFactory
 
    // 拒绝策略：当队列已满且线程数达到 maximumPoolSize 时
    // 如何处理新提交的任务
    new ThreadPoolExecutor.CallerRunsPolicy()   // handler
);

// 1. AbortPolicy（默认策略）
// 直接抛出 RejectedExecutionException 异常
// 适用场景：任务不允许丢失，调用方需要感知并处理异常
new ThreadPoolExecutor.AbortPolicy();
 
// 2. CallerRunsPolicy（调用者运行策略）
// 将任务回退给调用者线程执行（谁提交的谁执行）
// 优点：不会丢弃任务，且能自然降低提交速度（背压机制）
// 缺点：可能阻塞调用者线程
// 适用场景：所有任务都必须执行，不允许丢失
new ThreadPoolExecutor.CallerRunsPolicy();
 
// 3. DiscardPolicy（静默丢弃策略）
// 默默丢弃被拒绝的任务，不抛出任何异常
// 适用场景：允许任务丢失（如日志记录、监控打点等非关键任务）
new ThreadPoolExecutor.DiscardPolicy();
 
// 4. DiscardOldestPolicy（丢弃最旧策略）
// 丢弃队列中最早入队（等待最久）的任务，然后尝试重新提交当前任务
// 适用场景：优先保证最新任务的执行（如实时消息推送）
new ThreadPoolExecutor.DiscardOldestPolicy();

// 自定义拒绝策略：将被拒绝的任务记录到日志并告警
RejectedExecutionHandler customHandler = new RejectedExecutionHandler() {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 记录详细的拒绝信息，用于事后排查
        log.error("任务被拒绝! Task: {}, Pool: activeCount={}, queueSize={}, completedTask={}",
                r.toString(),
                executor.getActiveCount(),     // 活跃线程数
                executor.getQueue().size(),     // 队列中等待的任务数
                executor.getCompletedTaskCount() // 已完成的任务数
        );
        // 触发告警（如发送钉钉/飞书通知）
        alertService.sendAlert("线程池任务被拒绝，请检查系统负载!");
        // 根据业务决定：可以将任务写入消息队列延迟处理
        // messageQueue.send(r);
    }
};

// ❌ 不推荐：使用 Executors 工厂方法创建线程池
 
// newFixedThreadPool 底层使用无界的 LinkedBlockingQueue
// 任务堆积 → OOM
ExecutorService fixed = Executors.newFixedThreadPool(10);
 
// newCachedThreadPool 的 maximumPoolSize 为 Integer.MAX_VALUE
// 瞬间大量请求 → 创建海量线程 → OOM 或 CPU 100%
ExecutorService cached = Executors.newCachedThreadPool();
 
// newSingleThreadExecutor 同样使用无界队列
// 任务堆积 → OOM
ExecutorService single = Executors.newSingleThreadExecutor();

// ✅ 推荐：手动创建 ThreadPoolExecutor，所有参数显式可控
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    Runtime.getRuntime().availableProcessors(),  // 核心线程数 = CPU 核心数
    Runtime.getRuntime().availableProcessors() * 2, // 最大线程数 = CPU 核心数 * 2
    60L, TimeUnit.SECONDS,                       // 临时线程 60 秒空闲后回收
    new ArrayBlockingQueue<>(500),               // 有界队列，容量 500
    new ThreadPoolExecutor.CallerRunsPolicy()    // 拒绝策略：回退给调用者
);

// ThreadPoolExecutor 源码中状态的定义（简化版）
// 使用一个 int（32位）同时存储状态和线程数
// 高 3 位：线程池状态  |  低 29 位：线程数量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
 
// 29 位用于存储线程数量
private static final int COUNT_BITS = Integer.SIZE - 3;           // 29
 
// 线程数量的掩码：2^29 - 1 = 0001 1111 ... 1111（29个1）
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;
 
// 5 种状态的定义（高 3 位不同）
private static final int RUNNING    = -1 << COUNT_BITS; // 111 ...  接受新任务
private static final int SHUTDOWN   =  0 << COUNT_BITS; // 000 ...  不接受新任务
private static final int STOP       =  1 << COUNT_BITS; // 001 ...  强制停止
private static final int TIDYING    =  2 << COUNT_BITS; // 010 ...  整理中
private static final int TERMINATED =  3 << COUNT_BITS; // 011 ...  已终止
 
// 从 ctl 中提取线程池状态（取高 3 位）
private static int runStateOf(int c)     { return c & ~COUNT_MASK; }
// 从 ctl 中提取线程数量（取低 29 位）
private static int workerCountOf(int c)  { return c & COUNT_MASK; }

// CPU 密集型任务（如计算、加密、压缩）
// 线程数不宜过多，上下文切换本身就是开销
// 推荐公式：corePoolSize = CPU 核心数 + 1
int cpuCores = Runtime.getRuntime().availableProcessors(); // 获取 CPU 核心数
int cpuIntensivePoolSize = cpuCores + 1; // +1 是为了在某线程因缺页中断等偶发阻塞时仍能利用 CPU
 
// IO 密集型任务（如数据库查询、HTTP 请求、文件读写）
// 线程大部分时间在等待 IO，应该配置更多线程以提高 CPU 利用率
// 推荐公式：corePoolSize = CPU 核心数 * 2  或  CPU 核心数 / (1 - 阻塞系数)
// 阻塞系数通常在 0.8 ~ 0.9 之间
int ioIntensivePoolSize = cpuCores * 2;
// 更精确的公式（阻塞系数假设为 0.85）：
int precisePoolSize = (int) (cpuCores / (1 - 0.85)); // 约等于 CPU * 6.67

// 创建一个核心线程数为 3 的定时线程池
ScheduledExecutorService scheduler = new ScheduledThreadPoolExecutor(
    3,  // corePoolSize
    new ThreadFactory() {
        private final AtomicInteger counter = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setName("scheduler-" + counter.getAndIncrement());
            return t;
        }
    }
);
 
// ========== 1. schedule()：延迟执行一次 ==========
// 5 秒后执行，只执行一次
// 常用场景：超时取消订单、延迟重试
ScheduledFuture<?> delayed = scheduler.schedule(
    () -> System.out.println("5秒后执行: " + LocalDateTime.now()),
    5,                  // 延迟时间
    TimeUnit.SECONDS    // 时间单位
);
 
// 带返回值的延迟执行
ScheduledFuture<String> delayedWithResult = scheduler.schedule(
    () -> "计算结果: " + (42 * 42),   // Callable 任务
    3,                                  // 3 秒后执行
    TimeUnit.SECONDS
);
// String result = delayedWithResult.get(); // 阻塞获取结果
 
// ========== 2. scheduleAtFixedRate()：固定频率周期执行 ==========
// 以固定的速率重复执行任务
// 如果任务执行时间 < period，则等到 period 到期后执行下一次
// 如果任务执行时间 > period，则任务完成后立即开始下一次（不会并发执行）
scheduler.scheduleAtFixedRate(
    () -> {
        System.out.println("固定频率: " + LocalDateTime.now());
        // 假设这个任务执行需要 2 秒
    },
    0,                  // initialDelay：首次执行延迟 0 秒（立即开始）
    5,                  // period：每 5 秒执行一次
    TimeUnit.SECONDS
);
// 时间线：0s(执行) → 5s(执行) → 10s(执行) → ...
 
// ========== 3. scheduleWithFixedDelay()：固定延迟周期执行 ==========
// 上一次任务 **执行完成后**，等待固定延迟时间，再开始下一次
scheduler.scheduleWithFixedDelay(
    () -> {
        System.out.println("固定延迟: " + LocalDateTime.now());
        // 假设这个任务执行需要 2 秒
    },
    0,                  // initialDelay：首次执行延迟 0 秒
    5,                  // delay：每次执行完成后等 5 秒再执行下一次
    TimeUnit.SECONDS
);
// 时间线（假设任务耗时2秒）：0s(开始) → 2s(完成) → 7s(开始) → 9s(完成) → 14s(开始) → ...

// ScheduledThreadPoolExecutor 的核心内部结构（简化）
// 每个提交的任务都被包装为 ScheduledFutureTask
private class ScheduledFutureTask<V> extends FutureTask<V>
        implements RunnableScheduledFuture<V> {
 
    // 任务的序列号，用于打破时间相同时的排序（FIFO）
    private final long sequenceNumber;
 
    // 任务下次执行的绝对时间（纳秒）
    // 使用 System.nanoTime() 而非 System.currentTimeMillis()
    // 避免系统时钟修改导致的调度错乱
    private volatile long time;
 
    // 周期（正数 = FixedRate，负数 = FixedDelay，0 = 一次性任务）
    private final long period;
 
    // 周期任务完成后，重新设置 time 并放回队列
    private void setNextRunTime() {
        long p = period;
        if (p > 0) {
            // FixedRate: 下次时间 = 本次计划时间 + period
            time += p;
        } else {
            // FixedDelay: 下次时间 = 当前时间 + |period|
            time = triggerTime(-p);
        }
    }
}

// ❌ 危险：异常未捕获会导致定时任务停止调度
scheduler.scheduleAtFixedRate(() -> {
    // 假设第 3 次执行抛出异常
    int result = 1 / 0;  // ArithmeticException!
    // 从此以后，这个任务再也不会执行了
    // 而且不会有任何日志或报错（静默失败）
}, 0, 5, TimeUnit.SECONDS);
 
// ✅ 推荐：在任务内部捕获所有异常
scheduler.scheduleAtFixedRate(() -> {
    try {
        // 业务逻辑
        riskyBusinessLogic();
    } catch (Exception e) {
        // 记录日志，但不要抛出
        // 这样任务在下一个周期仍会继续执行
        log.error("定时任务执行异常", e);
    }
}, 0, 5, TimeUnit.SECONDS);

// 创建定时线程池，用于心跳检测
ScheduledExecutorService heartbeatScheduler = new ScheduledThreadPoolExecutor(
    1,  // 心跳任务只需 1 个核心线程
    r -> {
        Thread t = new Thread(r, "heartbeat-thread");
        t.setDaemon(true);  // 守护线程：JVM 退出时自动停止
        return t;
    }
);
 
// 每 30 秒向注册中心发送一次心跳
ScheduledFuture<?> heartbeatFuture = heartbeatScheduler.scheduleAtFixedRate(
    () -> {
        try {
            // 发送心跳请求
            boolean success = registryClient.sendHeartbeat();
            if (!success) {
                log.warn("心跳发送失败，将在下一周期重试");
            }
        } catch (Exception e) {
            log.error("心跳异常", e);
            // 不要抛出异常！否则后续心跳将停止
        }
    },
    0,                   // 启动后立即发送第一次心跳
    30,                  // 每 30 秒一次
    TimeUnit.SECONDS
);
 
// 应用关闭时取消心跳
// heartbeatFuture.cancel(false); // false = 不中断正在执行的任务
// heartbeatScheduler.shutdown();

ExecutorService pool = new ThreadPoolExecutor(
    2, 4, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(2),
    new ThreadPoolExecutor.AbortPolicy()
);

// ThreadPoolExecutor 的完整构造函数签名
public ThreadPoolExecutor(
    int corePoolSize,           // 核心线程数：始终存活（除非设置 allowCoreThreadTimeOut）
    int maximumPoolSize,        // 最大线程数：核心 + 救急线程的总上限
    long keepAliveTime,         // 救急线程的空闲存活时间
    TimeUnit unit,              // keepAliveTime 的时间单位
    BlockingQueue<Runnable> workQueue,  // 任务等待队列
    ThreadFactory threadFactory,        // 线程工厂：自定义线程名、优先级、守护标志等
    RejectedExecutionHandler handler    // 拒绝策略：队列满且线程满时如何处理新任务
)

// ❌ 危险：newFixedThreadPool 和 newSingleThreadExecutor 使用无界队列
// LinkedBlockingQueue 默认容量 Integer.MAX_VALUE，可能导致 OOM
ExecutorService bad1 = Executors.newFixedThreadPool(10);
 
// ❌ 危险：newCachedThreadPool 的 maximumPoolSize 为 Integer.MAX_VALUE
// 可能瞬间创建海量线程导致 OOM
ExecutorService bad2 = Executors.newCachedThreadPool();
 
// ✅ 推荐：手动创建，每个参数都经过深思熟虑
ThreadPoolExecutor good = new ThreadPoolExecutor(
    4,                                    // corePoolSize：CPU 核心数
    8,                                    // maximumPoolSize：核心数的 2 倍
    60L, TimeUnit.SECONDS,               // 救急线程空闲 60 秒后回收
    new ArrayBlockingQueue<>(200),        // 有界队列，容量 200
    new ThreadFactoryBuilder()            // Guava 提供的线程工厂构建器
        .setNameFormat("order-pool-%d")   // 自定义线程名，便于排查问题
        .build(),
    new ThreadPoolExecutor.CallerRunsPolicy()  // 队列满时调用者自己执行，实现反压
);

// 优雅关闭的标准模板（来自 ExecutorService 官方 JavaDoc）
executor.shutdown();                         // 1. 停止接收新任务，已提交任务继续执行
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {  // 2. 等待 60 秒
        executor.shutdownNow();              // 3. 超时则强制中断所有线程
        if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
            System.err.println("线程池未能完全关闭");  // 4. 仍未结束则记录日志
        }
    }
} catch (InterruptedException e) {
    executor.shutdownNow();                  // 5. 当前线程被中断，也要强制关闭
    Thread.currentThread().interrupt();      // 6. 保留中断状态
}

ExecutorService pool = new ThreadPoolExecutor(
    2, 4, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(2)
);