public ThreadPoolExecutor(
    int corePoolSize,                  // 核心线程数
    int maximumPoolSize,               // 最大线程数
    long keepAliveTime,                // 空闲存活时间
    TimeUnit unit,                     // 时间单位
    BlockingQueue<Runnable> workQueue, // 工作队列
    ThreadFactory threadFactory,       // 线程工厂
    RejectedExecutionHandler handler   // 拒绝策略
)

// 1. AbortPolicy（默认）：抛出 RejectedExecutionException
new ThreadPoolExecutor.AbortPolicy();

// 2. CallerRunsPolicy：由提交任务的线程执行
new ThreadPoolExecutor.CallerRunsPolicy();

// 3. DiscardPolicy：静默丢弃任务
new ThreadPoolExecutor.DiscardPolicy();

// 4. DiscardOldestPolicy：丢弃队列中最老的任务
new ThreadPoolExecutor.DiscardOldestPolicy();

// 5. 自定义策略
new RejectedExecutionHandler() {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 记录日志、持久化、重试等
        log.warn("任务被拒绝: {}", r.toString());
    }
};

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    
    int c = ctl.get();
    
    // 1. 当前线程数 < 核心线程数，创建核心线程
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    
    // 2. 核心线程已满，尝试入队
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 双重检查：线程池可能在入队后关闭
        if (!isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3. 队列满，尝试创建非核心线程
    else if (!addWorker(command, false))
        // 4. 达到最大线程数，执行拒绝策略
        reject(command);
}

// 固定大小线程池（队列无界，可能 OOM）
ExecutorService fixed = Executors.newFixedThreadPool(10);

// 缓存线程池（最大线程无界，可能创建过多线程）
ExecutorService cached = Executors.newCachedThreadPool();

// 单线程池（队列无界，可能 OOM）
ExecutorService single = Executors.newSingleThreadExecutor();

// 定时任务线程池
ScheduledExecutorService scheduled = Executors.newScheduledThreadPool(5);

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10,                                     // 核心线程数
    20,                                     // 最大线程数
    60L, TimeUnit.SECONDS,                  // 空闲存活时间
    new LinkedBlockingQueue<>(1000),        // 有界队列
    new ThreadFactoryBuilder()
        .setNameFormat("业务线程-%d")
        .setDaemon(false)
        .build(),                           // 自定义线程工厂
    new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

// 提交任务
executor.execute(() -> {
    // 任务逻辑
});

// 优雅关闭
executor.shutdown();
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow();
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
}

ForkJoinPool forkJoinPool = new ForkJoinPool(
    Runtime.getRuntime().availableProcessors()
);

// 递归任务
class SumTask extends RecursiveTask<Long> {
    private final long[] array;
    private final int start, end;
    private static final int THRESHOLD = 1000;

    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            // 直接计算
            long sum = 0;
            for (int i = start; i < end; i++) sum += array[i];
            return sum;
        }
        // 分治
        int mid = (start + end) / 2;
        SumTask left = new SumTask(array, start, mid);
        SumTask right = new SumTask(array, mid, end);
        left.fork();  // 异步执行
        return right.compute() + left.join();  // 合并结果
    }
}

Long result = forkJoinPool.invoke(new SumTask(array, 0, array.length));

// CPU 密集型任务：N + 1（N 为 CPU 核心数）
int cpuIntensive = Runtime.getRuntime().availableProcessors() + 1;

// IO 密集型任务：2N 或 N * (1 + 等待时间/计算时间)
int ioIntensive = Runtime.getRuntime().availableProcessors() * 2;

// 混合型任务：根据实际压测调整

// 队列容量 = 每秒任务数 × 任务平均耗时 × 允许等待时间系数
int queueSize = (int) (taskPerSecond * avgTaskTime * 2);

// 运行时动态调整
executor.setCorePoolSize(newCoreSize);
executor.setMaximumPoolSize(newMaxSize);

ThreadPoolExecutor executor = ...;

// 监控指标
int activeCount = executor.getActiveCount();           // 活跃线程数
int poolSize = executor.getPoolSize();                 // 当前线程数
int queueSize = executor.getQueue().size();            // 队列任务数
long completedCount = executor.getCompletedTaskCount();// 已完成任务数
long taskCount = executor.getTaskCount();              // 总任务数

// 使用率 = 活跃线程数 / 最大线程数
double usage = (double) activeCount / executor.getMaximumPoolSize();

// 可结合 Prometheus + Grafana 做可视化监控

// 推荐配置模板
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    maxPoolSize,
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(queueCapacity),
    new ThreadFactoryBuilder().setNameFormat("pool-%d").build(),
    (r, e) -> log.error("任务被拒绝，队列已满")
);

// 预热核心线程（可选）
executor.prestartAllCoreThreads();