public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

// JDK 源码：ThreadPoolExecutor 核心字段
public class ThreadPoolExecutor extends AbstractExecutorService {

    // ① ctl：高 3 位 = 运行状态，低 29 位 = Worker 数量
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

    // ② 线程池参数（构造时设定，不可修改）
    private final BlockingQueue<Runnable> workQueue;       // 工作队列
    private final ReentrantLock mainLock = new ReentrantLock(); // 全局锁，保护 workers 集合
    private final HashSet<Worker> workers = new HashSet<>();   // 存放所有存活 Worker
    private final Condition termination = mainLock.newCondition(); // 等待终止的条件变量
    private int largestPoolSize;       // 历史最大同时线程数（监控用）
    private long completedTaskCount;   // 已完成任务总数（所有 Worker 的 completedTasks 之和）
    private volatile ThreadFactory threadFactory;          // 线程工厂（volatile，可替换）
    private volatile RejectedExecutionHandler handler;     // 拒绝策略（volatile，可替换）
    private volatile long keepAliveTime;                   // 空闲存活时间（volatile，可动态修改）
    private volatile boolean allowCoreThreadTimeOut;       // 是否允许核心线程超时
    private volatile int corePoolSize;                     // 核心线程数（volatile，可动态修改）
    private volatile int maximumPoolSize;                  // 最大线程数（volatile，可动态修改）

    // ③ 默认拒绝策略
    private static final RejectedExecutionHandler defaultHandler = new AbortPolicy();
}

// JDK 源码：ThreadPoolExecutor.Worker 内部类（完整注释版）
private final class Worker
        extends AbstractQueuedSynchronizer   // ① 继承 AQS，充当不可重入的互斥锁
        implements Runnable {               // ② 实现 Runnable，是线程的执行入口

    private static final long serialVersionUID = 6138294804551838833L;

    final Thread thread;                    // ③ 执行任务的线程（通过线程工厂创建）
    Runnable firstTask;                     // ④ 创建 Worker 时的首个任务（可为 null）
    volatile long completedTasks;           // ⑤ 该 Worker 已完成的任务计数

    // 构造器
    Worker(Runnable firstTask) {
        setState(-1);                       // ⑥ 抑制中断：构造期间 state=-1，lock 失败
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);  // ⑦ 将自身作为 Runnable 创建线程
    }

    // Runnable 入口：委托给外部 runWorker()
    public void run() {
        runWorker(this);                    // ⑧ 线程启动后，进入 runWorker 执行循环
    }

    // ---- AQS 锁方法 ----
    protected boolean isHeldExclusively() { return getState() != 0; } // ⑨ state≠0 表示已锁定

    protected boolean tryAcquire(int unused) {                         // ⑩ CAS 抢锁
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }

    protected boolean tryRelease(int unused) {                         // ⑪ 释放锁
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }

    public void lock()        { acquire(1); }      // ⑫ 阻塞获取锁
    public boolean tryLock()  { return tryAcquire(1); } // ⑬ 非阻塞尝试获取
    public void unlock()      { release(1); }      // ⑭ 释放锁
    public boolean isLocked() { return isHeldExclusively(); } // ⑮ 是否已锁定
}

// 在 runWorker() 最开头：
w.unlock();  // 将 state 从 -1 改为 0，允许中断

// JDK 源码：ctl 位运算设计
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;       // 29
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;  // 2^29 - 1 ≈ 5.37 亿

// 五个状态常量的二进制布局（高 3 位不同值，低 29 位全 0）
private static final int RUNNING    = -1 << COUNT_BITS;  // 111 000...000
private static final int SHUTDOWN   =  0 << COUNT_BITS;  // 000 000...000
private static final int STOP       =  1 << COUNT_BITS;  // 001 000...000
private static final int TIDYING    =  2 << COUNT_BITS;  // 010 000...000
private static final int TERMINATED =  3 << COUNT_BITS;  // 011 000...000

// 三个位运算工具方法
private static int runStateOf(int c)     { return c & ~CAPACITY; }  // 取高 3 位（状态）
private static int workerCountOf(int c)  { return c & CAPACITY;  }  // 取低 29 位（Worker 数）
private static int ctlOf(int rs, int wc) { return rs | wc;       }  // 合并（状态 | Worker 数）

// JDK 源码：ThreadPoolExecutor.execute()
public void execute(Runnable command) {
    if (command == null) throw new NullPointerException();
    int c = ctl.get();

    // 第1步：当前线程数 < corePoolSize → 直接创建核心线程
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))                       // true = 核心线程模式
            return;
        c = ctl.get();                                     // 失败则重读 ctl
    }

    // 第2步：线程池 RUNNING → 尝试入队
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (!isRunning(recheck) && remove(command))       // double check①：状态变了?
            reject(command);
        else if (workerCountOf(recheck) == 0)              // double check②：线程都死了?
            addWorker(null, false);                        // 补充一个线程
    }

    // 第3步：队列满 → 尝试创建非核心线程 → 失败则拒绝
    else if (!addWorker(command, false))                   // false = 非核心线程模式
        reject(command);
}

// JDK 源码：addWorker()
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (int c = ctl.get();;) {
        // ① 状态合法性检查
        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP)     // STOP 及以上 → 决不允许
                || firstTask != null          // SHUTDOWN + 带任务 → 不允许
                || workQueue.isEmpty()))      // SHUTDOWN + 队列空 → 没必要
            return false;

        for (;;) {
            // ② 容量检查：core=true 则上限为核心线程数，否则为最大线程数
            if (workerCountOf(c) >= ((core ? corePoolSize : maximumPoolSize)
                                      & CAPACITY))
                return false;
            if (compareAndIncrementWorkerCount(c))    // CAS 将 Worker 计数 +1
                break retry;                         // 成功，跳出双层循环
            c = ctl.get();
            if (runStateAtLeast(c, SHUTDOWN))         // 状态变了，回外层重新检查
                continue retry;
        }
    }

    // ③ 创建 Worker
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        w = new Worker(firstTask);                   // 内部：setState(-1) + 创建线程
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();                          // ④ 持 mainLock 操作 workers
            try {
                int c = ctl.get();
                if (isRunning(c) ||                   // RUNNING 状态
                    (runStateLessThan(c, STOP) && firstTask == null)) { // SHUTDOWN + 无任务
                    if (t.isAlive())                  // 新线程不应已存活
                        throw new IllegalThreadStateException();
                    workers.add(w);                   // ⑤ 加入 HashSet
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;          // ⑥ 更新历史最大线程数
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();
            }
            if (workerAdded) {
                t.start();                             // ⑦ 启动线程 → Worker.run() → runWorker()
                workerStarted = true;
            }
        }
    } finally {
        if (!workerStarted)
            addWorkerFailed(w);                       // ⑧ 回滚清理
    }
    return workerStarted;
}

// JDK 源码：addWorkerFailed()
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w);                // 从 workers 中移除
        decrementWorkerCount();               // Worker 计数 -1
        tryTerminate();                       // 尝试进入 TERMINATED
    } finally {
        mainLock.unlock();
    }
}

// JDK 源码：runWorker()
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;                        // ① firstTask 已取出，置 null
    w.unlock();                                // ② state 从 -1 改到 0，允许中断

    boolean completedAbruptly = true;          // ③ 是否异常退出（默认 true）
    try {
        while (task != null || (task = getTask()) != null) {  // ④ 循环获取任务
            w.lock();                          // ⑤ 加锁，标记 Worker 忙碌

            // ⑥ 响应中断检查
            if ((runStateAtLeast(ctl.get(), STOP) ||            // 线程池已 STOP
                 (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)))
                && !wt.isInterrupted())
                wt.interrupt();

            try {
                beforeExecute(wt, task);       // ⑦ 钩子：执行前（子类可覆盖）
                task.run();                    // ⑧ 执行用户任务
                afterExecute(task, null);      // ⑨ 钩子：执行后
            } catch (Throwable ex) {
                afterExecute(task, ex);        // ⑩ 钩子：异常时
                throw ex;
            } finally {
                task = null;
                w.completedTasks++;            // ⑪ 该 Worker 完成计数 +1
                w.unlock();                    // ⑫ 解锁，标记 Worker 空闲
            }
        }
        completedAbruptly = false;             // ⑬ 正常退出循环
    } finally {
        processWorkerExit(w, completedAbruptly);  // ⑭ Worker 退出处理
    }
}

// JDK 源码：getTask()
private Runnable getTask() {
    boolean timedOut = false;                    // 标记上一次 poll 是否超时
    for (;;) {
        int c = ctl.get();

        // ① 是否应该让 Worker 退出
        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;                         // 返回 null → runWorker 退出循环
        }

        int wc = workerCountOf(c);
        // ② 是否需要超时取任务
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        // ③ 是否满足退出条件
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;                            // CAS 失败则重试
        }

        try {
            // ④ 从队列取任务
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :  // 超时版
                workQueue.take();                                       // 阻塞版
            if (r != null)
                return r;
            timedOut = true;                     // poll 超时，标记
        } catch (InterruptedException retry) {
            timedOut = false;                    // 被中断≠超时，重置标记
        }
    }
}

// JDK 源码：processWorkerExit()
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // ① 如果是异常退出，Worker 计数需要手动递减（正常退出已在 getTask 中递减）
    if (completedAbruptly)
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;  // ② 累加已完成任务数
        workers.remove(w);                       // ③ 从 workers 移除
    } finally {
        mainLock.unlock();
    }

    tryTerminate();                              // ④ 尝试进入 TERMINATED

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) {             // ⑤ 线程池未 STOP → 可能需要补充线程
        if (!completedAbruptly) {                // 正常退出
            // allowCoreThreadTimeOut 或 workerCount > corePoolSize → min=0 (不强制补充)
            // 否则 min = corePoolSize (保证至少保留核心线程)
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && !workQueue.isEmpty())
                min = 1;                         // 队列有任务则至少保留 1 个
            if (workerCountOf(c) >= min)
                return;                          // 足够，不补充
        }
        addWorker(null, false);                  // ⑥ 补充一个 Worker
    }
}

// JDK 源码：tryTerminate()
final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        // ① 不满足终止条件：还在 RUNNING / 已 TIDYING 以上 / SHUTDOWN 但队列不空
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateLessThan(c, STOP) && !workQueue.isEmpty()))
            return;

        // ② workerCount 不为 0 → 中断一个空闲 Worker 使其去传播关闭逻辑
        if (workerCountOf(c) != 0) {
            interruptIdleWorkers(ONLY_ONE);       // 只中断一个
            return;
        }

        // ③ workerCount == 0 → 状态推进到 TIDYING，再推进到 TERMINATED
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {  // CAS: 状态→TIDYING
                try {
                    terminated();                 // ④ 钩子方法（子类覆盖）
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0)); // ⑤ 最终状态→TERMINATED
                    termination.signalAll();       // ⑥ 唤醒所有 awaitTermination 的线程
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
    }
}

// JDK 源码：shutdown() — 平缓关闭
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();               // 安全管理器检查
        advanceRunState(SHUTDOWN);           // ① CAS 推进状态 → SHUTDOWN
        interruptIdleWorkers();              // ② 只中断空闲 Worker
        onShutdown();                        // ③ 钩子（ScheduledThreadPoolExecutor 用）
    } finally { mainLock.unlock(); }
    tryTerminate();                          // ④ 尝试进入 TERMINATED
}

// JDK 源码：shutdownNow() — 立即关闭
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);               // ① CAS 推进状态 → STOP
        interruptWorkers();                  // ② 中断所有 Worker（不管是否忙碌）
        tasks = drainQueue();                // ③ 清空队列，返回未执行的任务
    } finally { mainLock.unlock(); }
    tryTerminate();
    return tasks;
}

// interruptIdleWorkers()：只中断空闲 Worker
private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            if (!t.isInterrupted() && w.tryLock()) {  // ★ tryLock 成功 = Worker 空闲
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne) break;
        }
    } finally { mainLock.unlock(); }
}

// interruptWorkers()：中断所有 Worker
private void interruptWorkers() {
    for (Worker w : workers)
        w.interruptIfStarted();              // 中断已启动的线程（不管 AQS 状态）
}

// 启动一个核心线程（即使没有任务）
public boolean prestartCoreThread() {
    return workerCountOf(ctl.get()) < corePoolSize
           && addWorker(null, true);         // firstTask=null，线程从 getTask 取任务
}

// 启动所有核心线程
public int prestartAllCoreThreads() {
    int n = 0;
    while (addWorker(null, true))
        ++n;
    return n;                                // 返回实际启动的线程数
}

// AbstractExecutorService.submit()
public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);      // ① 包装为 FutureTask
    execute(ftask);                                   // ② 走正常的 execute 流程
    return ftask;                                     // ③ 返回 Future 供调用者等待
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

// JDK 源码：AbortPolicy
public static class AbortPolicy implements RejectedExecutionHandler {
    public AbortPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString()
            + " rejected from " + e.toString());     // 直接抛异常
    }
}

// JDK 源码：CallerRunsPolicy
public static class CallerRunsPolicy implements RejectedExecutionHandler {
    public CallerRunsPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();                                 // 由调用者线程直接执行
        }
    }
}

// JDK 源码：DiscardOldestPolicy
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    public DiscardOldestPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();                     // 丢弃队列头部（最旧）任务
            e.execute(r);                            // 重新提交当前任务
        }
    }
}

// JDK 源码：DiscardPolicy
public static class DiscardPolicy implements RejectedExecutionHandler {
    public DiscardPolicy() { }
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        // 什么也不做
    }
}

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5, 20, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100));

executor.execute(() -> doSomething());

// 关闭
executor.shutdown();
executor.awaitTermination(60, TimeUnit.SECONDS);

Future<String> future = executor.submit(() -> computeResult());
String result = future.get(5, TimeUnit.SECONDS);  // 带超时等待

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
            executor.shutdownNow();              // 超时强制关闭
            executor.awaitTermination(10, TimeUnit.SECONDS);
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
        Thread.currentThread().interrupt();
    }
}));

CountDownLatch latch = new CountDownLatch(100);
for (int i = 0; i < 100; i++) {
    executor.execute(() -> {
        try { process(); }
        finally { latch.countDown(); }
    });
}
latch.await(30, TimeUnit.SECONDS);

@Bean("orderExecutor")
public ThreadPoolTaskExecutor orderExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(10);
    executor.setMaxPoolSize(50);
    executor.setQueueCapacity(200);
    executor.setKeepAliveSeconds(60);
    executor.setThreadNamePrefix("order-");
    executor.setRejectedExecutionHandler(
        new ThreadPoolExecutor.CallerRunsPolicy());
    executor.setWaitForTasksToCompleteOnShutdown(true);
    executor.setAwaitTerminationSeconds(60);
    executor.initialize();
    return executor;
}

RejectedExecutionHandler handler = (r, executor) -> {
    log.error("任务被拒绝! active={}, poolSize={}, queueSize={}, completedTasks={}",
        executor.getActiveCount(), executor.getPoolSize(),
        executor.getQueue().size(), executor.getCompletedTaskCount());
    // 可选降级：持久化到数据库、发 MQ 重试
    saveToDeadLetterQueue(r);
};

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10, 50, 60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(200),
    new ThreadFactoryBuilder().setNameFormat("biz-%d").build(),
    handler);

ThreadFactory factory = new ThreadFactoryBuilder()
    .setNameFormat("order-processor-%d")
    .build();

// 以 Dynamic TP 为例的简化示意
@Component
public class DtpMonitor {
    @Resource
    private ThreadPoolExecutor executor;

    @EventListener
    public void onConfigChange(ConfigChangeEvent event) {
        if (event.getKey().equals("threadpool.order")) {
            ThreadPoolConfig config = event.getNewValue();
            executor.setCorePoolSize(config.getCorePoolSize());
            executor.setMaximumPoolSize(config.getMaxPoolSize());
            executor.setKeepAliveTime(config.getKeepAlive(), TimeUnit.SECONDS);
        }
    }
}