← 返回首页 📚 实战课程
📑 本篇章节导航 (共4章,点击直达)
一、理论篇(30%)—— 从ctl到位运算的源码级拆解二、动手篇(40%)—— 生产级配置与动态调优三、面试模拟篇(20%)—— 追问链式考核四、练习篇(10%)

P1-03 - 线程池原理与生产配置

定位:你天天用线程池,配置参数也背过。但面试官问"ctl的高3位是什么""execute()方法中什么情况下直接拒绝""Worker为什么继承AQS""getTask()怎么实现超时退出",你答不精确。本节专治这个gap。

一、理论篇(30%)—— 从ctl到位运算的源码级拆解

1.1 ctl:一个AtomicInteger存两个值


// ThreadPoolExecutor 的核心控制变量
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

// ctl = 高3位(runState) + 低29位(workerCount)
// 32位AtomicInteger的布局:

// ┌───────┬──────────────────────────────────────┐
// │ 高3位  │            低29位                      │
// │runState│         workerCount                   │
// └───────┴──────────────────────────────────────┘

private static final int COUNT_BITS = Integer.SIZE - 3;     // 29
private static final int CAPACITY   = (1 << COUNT_BITS) - 1; // 0001...111(29个1)

// runState 高3位值(面试必背)
private static final int RUNNING    = -1 << COUNT_BITS; // 111 000...0  → 能接受新任务,能处理队列
private static final int SHUTDOWN   =  0 << COUNT_BITS; // 000 000...0  → 不接受新任务,处理完队列
private static final int STOP       =  1 << COUNT_BITS; // 001 000...0  → 不接受新任务,中断进行中的任务
private static final int TIDYING    =  2 << COUNT_BITS; // 010 000...0  → 所有任务完成,workerCount=0
private static final int TERMINATED =  3 << COUNT_BITS; // 011 000...0  → terminated()执行完毕

// 位运算辅助方法
private static int runStateOf(int c)   { return c & ~CAPACITY; }  // 取高3位
private static int workerCountOf(int c) { return c & CAPACITY; }  // 取低29位
private static int ctlOf(int rs, int wc) { return rs | wc; }     // 合并

状态转换图:


RUNNING → SHUTDOWN → STOP → TIDYING → TERMINATED
   │         │          │        │
   │     shutdown()   shutdownNow()  workerCount==0
   │                    │                │
   │                    │           terminated()
   │                    │
   └──shutdownNow()也可直接到──┘

重要:
- RUNNING 是负数(高3位111),所以 runState < SHUTDOWN 意味着 RUNNING
- 状态只能从小到大变化(数值上),不能回退

1.2 execute() 完整流程(源码级)


// ThreadPoolExecutor.execute() 源码逻辑(简化版)
public void execute(Runnable command) {
    int c = ctl.get();

    // ===== 步骤1:当前线程数 < corePoolSize =====
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))  // true=核心线程
            return;
        c = ctl.get(); // addWorker失败,重新获取ctl
    }

    // ===== 步骤2:线程数 >= corePoolSize,尝试入队 =====
    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)) // false=非核心线程
        reject(command);  // 非核心线程也创建不了(达到maximumPoolSize),拒绝
}

// 面试关键:execute中的三个reject触发条件
// 1. 线程池非RUNNING状态(步骤2的双重检查)
// 2. 队列满 + 线程数达到maximumPoolSize(步骤3)

1.3 Worker → runWorker → getTask 生命周期


// Worker 本身继承了 AQS(不可重入锁)+ 实现了 Runnable
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    final Thread thread;        // 工作线程
    Runnable firstTask;         // 第一个任务(可能为null)
    volatile long completedTasks;

    Worker(Runnable firstTask) {
        setState(-1); // 禁止在runWorker之前被中断
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    public void run() {
        runWorker(this);
    }
}

// runWorker 流程:
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); // 允许中断(state从-1变为0)

    boolean completedAbruptly = true;
    try {
        // 循环获取任务:先执行firstTask,再从队列取
        while (task != null || (task = getTask()) != null) {
            w.lock(); // Worker加锁(标识正在执行任务)
            // 检查线程池状态...
            try {
                beforeExecute(wt, task); // 钩子方法
                try {
                    task.run();          // 执行任务
                    afterExecute(task, null); // 钩子
                } catch (Throwable ex) {
                    afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                task = null;
                w.completedTasks++;
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly); // 线程退出清理
    }
}

// getTask:核心线程阻塞等待 / 非核心线程超时等待
private Runnable getTask() {
    boolean timedOut = false;
    for (;;) {
        int c = ctl.get();
        int wc = workerCountOf(c);

        // timed = 是否允许超时(核心线程在allowCoreThreadTimeOut=true时也超时)
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            // CAS减少workerCount,返回null → 线程退出
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }

        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : // 超时获取
                workQueue.take(); // 阻塞等待(核心线程)
            if (r != null) return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

Worker生命周期完整图:


execute(task)
    │
    ├── addWorker(task, true/false)
    │       │
    │       ├── CAS增加workerCount
    │       └── 创建Worker → newThread(worker) → thread.start()
    │                                       │
    └───────────────────────────────────────┘
                                            │
                                            ▼
                                    runWorker(worker)
                                            │
                                    while (getTask() != null)
                                      │
                                      ├── task.run()    ← 执行任务
                                      │
                                      └── getTask()返回null时退出
                                              │
                                              ├── 线程数 > maximumPoolSize
                                              ├── 非核心线程超时(poll超时)
                                              └── 线程池状态 >= STOP
                                              │
                                              ▼
                                    processWorkerExit()
                                    (清理Worker,可能创建替代线程)

1.4 四种拒绝策略

策略行为适用场景
AbortPolicy抛RejectedExecutionException默认策略,适合需要感知任务丢失的场景
CallerRunsPolicy由提交任务的线程自己执行限流降级,不丢任务
DiscardPolicy静默丢弃可容忍任务丢失
DiscardOldestPolicy丢弃队列头(最老的任务),重新提交优先处理新任务

1.5 线程池大小计算


CPU密集型任务:
  线程数 = CPU核心数 + 1
  (+1是为了在某个线程偶尔因为页缺失等原因暂停时,额外线程能利用CPU)

IO密集型任务:
  线程数 = CPU核心数 × (1 + W/C)
  W = 等待时间,C = 计算时间
  经验值:CPU核心数 × 2 ~ CPU核心数 × 10

生产环境的实际做法:
  不要用公式硬算,先用合理值上线,然后通过监控指标动态调整
  关键指标:活跃线程数、队列长度、完成任务数、拒绝次数

二、动手篇(40%)—— 生产级配置与动态调优

2.1 不同场景的线程池配置模板


import java.util.concurrent.*;

/**
 * 生产环境线程池配置模板
 */
public class ThreadPoolConfig {

    // ========== 场景1:Web服务器处理请求 ==========
    // 特点:IO密集,任务多但单个任务时间短
    public static ThreadPoolExecutor webServerPool() {
        return new ThreadPoolExecutor(
            32,                                     // 核心线程:并发量大
            200,                                    // 最大线程:应对突发
            60, TimeUnit.SECONDS,                   // 非核心线程空闲60秒回收
            new LinkedBlockingQueue<>(10000),        // 有界队列,容量10000
            new ThreadFactory() {                    // 自定义线程工厂
                private int count = 0;
                @Override
                public Thread newThread(Runnable r) {
                    return new Thread(r, "web-worker-" + (count++));
                }
            },
            new ThreadPoolExecutor.CallerRunsPolicy() // 降级:调用者线程执行
        );
    }

    // ========== 场景2:批处理任务 ==========
    // 特点:CPU密集,任务数量可控
    public static ThreadPoolExecutor batchProcessPool() {
        int cpuCores = Runtime.getRuntime().availableProcessors();
        return new ThreadPoolExecutor(
            cpuCores + 1,                            // 核心线程 = CPU+1
            cpuCores + 1,                            // 最大线程 = 核心(不需要额外线程)
            0, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1000),
            new ThreadPoolExecutor.AbortPolicy()     // 队列满直接报错
        );
    }

    // ========== 场景3:定时/周期任务 ==========
    public static ScheduledThreadPoolExecutor scheduledPool() {
        return new ScheduledThreadPoolExecutor(
            4, // 核心线程数
            new ThreadFactory() {
                private int count = 0;
                @Override
                public Thread newThread(Runnable r) {
                    Thread t = new Thread(r, "scheduled-" + (count++));
                    t.setDaemon(true); // 守护线程,不阻止JVM退出
                    return t;
                }
            }
        );
    }
}

2.2 自定义拒绝策略(记录日志 + 降级)


/**
 * 自定义拒绝策略:记录日志 + 降级处理
 */
public class LogAndFallbackPolicy implements RejectedExecutionHandler {

    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // 1. 记录监控指标
        System.err.println("[REJECT] 任务被拒绝!" +
            " 池大小=" + executor.getPoolSize() +
            " 活跃=" + executor.getActiveCount() +
            " 队列=" + executor.getQueue().size());

        // 2. 降级策略:如果是非关键任务,丢弃
        if (r instanceof NonCriticalTask) {
            System.err.println("[REJECT] 非关键任务,静默丢弃");
            return;
        }

        // 3. 关键任务:调用者线程执行(兜底)
        if (!executor.isShutdown()) {
            System.err.println("[REJECT] 关键任务,降级为同步执行");
            r.run();
        }
    }

    static class NonCriticalTask implements Runnable {
        @Override public void run() { /* 日志上报等非关键任务 */ }
    }
}

2.3 线程池动态调优


import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 线程池动态调优 + 监控
 *
 * 生产环境可以通过配置中心(如Nacos)动态修改参数
 * 然后调用 setCorePoolSize / setMaximumPoolSize 实时生效
 */
public class DynamicThreadPool {

    private final ThreadPoolExecutor executor;

    public DynamicThreadPool() {
        this.executor = new ThreadPoolExecutor(
            4, 8, 60, TimeUnit.SECONDS,
            new ResizableCapacityLinkedBlockingQueue<>(100),
            new NamedThreadFactory("dynamic"),
            new ThreadPoolExecutor.CallerRunsPolicy()
        );
    }

    /**
     * 动态调整核心线程数(无需重启)
     *
     * 注意事项:
     * 1. 新值 > 旧值:立即创建新线程处理队列中的任务
     * 2. 新值 < 旧值:多余的核心线程会在下次getTask()超时后退出
     */
    public void setCorePoolSize(int newSize) {
        System.out.println("调整核心线程数: " +
            executor.getCorePoolSize() + " → " + newSize);
        executor.setCorePoolSize(newSize);
        // setMaximumPoolSize也必须 >= corePoolSize
        if (newSize > executor.getMaximumPoolSize()) {
            executor.setMaximumPoolSize(newSize);
        }
    }

    /**
     * 打印线程池监控指标
     */
    public void printMetrics() {
        System.out.println("=== 线程池监控 ===");
        System.out.println("核心线程数: " + executor.getCorePoolSize());
        System.out.println("最大线程数: " + executor.getMaximumPoolSize());
        System.out.println("当前线程数: " + executor.getPoolSize());
        System.out.println("活跃线程数: " + executor.getActiveCount());
        System.out.println("队列大小: " + executor.getQueue().size());
        System.out.println("已完成任务: " + executor.getCompletedTaskCount());
        System.out.println("总任务数: " + executor.getTaskCount());
        System.out.println("================");
    }

    // 自定义线程工厂
    static class NamedThreadFactory implements ThreadFactory {
        private final AtomicInteger count = new AtomicInteger(0);
        private final String prefix;

        NamedThreadFactory(String prefix) { this.prefix = prefix; }

        @Override
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r, prefix + "-" + count.incrementAndGet());
            t.setDaemon(false);
            // 生产环境建议设置UncaughtExceptionHandler
            t.setUncaughtExceptionHandler((thread, ex) ->
                System.err.println("线程 " + thread.getName() + " 异常: " + ex.getMessage()));
            return t;
        }
    }

    public static void main(String[] args) throws Exception {
        DynamicThreadPool pool = new DynamicThreadPool();

        // 提交20个任务
        for (int i = 0; i < 20; i++) {
            final int idx = i;
            pool.executor.submit(() -> {
                try { Thread.sleep(2000); } catch (Exception e) {}
                System.out.println("任务" + idx + " 由 " +
                    Thread.currentThread().getName() + " 执行");
            });
        }

        pool.printMetrics();
        Thread.sleep(1000);

        // 动态扩容
        pool.setCorePoolSize(10);
        Thread.sleep(1000);
        pool.printMetrics();

        pool.executor.shutdown();
        pool.executor.awaitTermination(30, TimeUnit.SECONDS);
    }
}

2.4 线程池线程泄漏排查实验


import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 演示线程池常见的"线程泄漏"问题
 *
 * 场景:任务中抛出未捕获异常,导致Worker线程退出
 */
public class ThreadLeakDemo {

    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
            4, 4, 0, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(100)
        );

        // 提交10个任务,其中3个会抛异常
        for (int i = 0; i < 10; i++) {
            final int idx = i;
            pool.submit(() -> {
                if (idx == 3 || idx == 5 || idx == 7) {
                    throw new RuntimeException("模拟任务" + idx + "异常");
                }
                try { Thread.sleep(1000); } catch (Exception e) {}
                return "任务" + idx + "完成";
            });
        }

        Thread.sleep(500);
        System.out.println("线程数: " + pool.getPoolSize()); // 期望4,但可能 < 4
        System.out.println("活跃线程: " + pool.getActiveCount());

        // 解决方案1:任务内部try-catch
        // 解决方案2:设置UncaughtExceptionHandler
        // 解决方案3:覆盖afterExecute钩子

        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);
    }
}

三、面试模拟篇(20%)—— 追问链式考核

Q1: 线程池的execute()方法执行流程?

追问链:


Q1.1: 为什么步骤2入队成功后还要双重检查线程池状态?
→ 入队操作不是原子的,入队期间线程池可能被shutdown
→ 如果入队后线程池已经不是RUNNING,需要回滚(从队列remove)并拒绝

Q1.2: 步骤2中 workerCountOf(recheck) == 0 是什么场景?
→ 所有核心线程刚好都执行完退出了(allowCoreThreadTimeOut=true或核心线程意外死亡)
→ 但队列里还有任务,所以需要addWorker(null, false)创建一个线程来处理

Q1.3: 什么情况下execute会直接拒绝(不走拒绝策略)?
→ 不会。execute的三条路径最终都会到达reject()或者成功提交
→ 拒绝策略一定是在reject()中触发的

Q1.4: 如果核心线程数=0,任务会怎样?
→ 直接入队(步骤2),然后addWorker(null, false)创建非核心线程
→ JDK 7之前核心线程数为0时行为不同(直接创建非核心线程)

Q2: Worker为什么要继承AQS?

追问链:


Q2.1: Worker的锁是不可重入的,为什么?
→ 为了标识线程是否正在执行任务
→ runWorker()中每次执行任务前lock(),执行完unlock()
→ shutdown()时tryLock()成功说明线程空闲,可以中断

Q2.2: Worker构造时state=-1是做什么的?
→ 防止在线程真正开始执行任务前被中断
→ runWorker()中第一次unlock()将state从-1变为0
→ 之后才允许interruptIfStarted()

Q2.3: 线程池shutdown和shutdownNow的区别?
→ shutdown:状态设为SHUTDOWN,中断空闲线程(tryLock成功的)
→ shutdownNow:状态设为STOP,中断所有线程(包括正在执行的)
→ shutdownNow还会清空队列并返回未执行的任务列表

Q3: 核心线程会被回收吗?

追问链:


Q3.1: 默认情况下核心线程会超时退出吗?
→ 不会。默认allowCoreThreadTimeOut=false
→ 核心线程在getTask()中用workQueue.take()阻塞等待

Q3.2: 怎么让核心线程也超时退出?
→ 设置allowCoreThreadTimeOut=true
→ 此时核心线程也用poll(keepAliveTime)等待,超时后退出

Q3.3: 线程池中线程的数量会在什么范围内变化?
→ 最少:0(allowCoreThreadTimeOut=true时)或corePoolSize
→ 最多:maximumPoolSize
→ 变化触发:任务提交(增加)和getTask()超时(减少)

常见踩坑

1. 用Executors.newFixedThreadPool() —— 内部用无界LinkedBlockingQueue,任务堆积导致OOM

2. 用Executors.newCachedThreadPool() —— 最大线程数=Integer.MAX_VALUE,高并发时创建大量线程

3. 任务抛异常后不处理 —— Worker线程退出,线程池"泄漏"

4. corePoolSize > maximumPoolSize —— setCorePoolSize时会自动修正maximumPoolSize

5. 忘记shutdown —— 导致JVM无法退出(非守护线程)

6. 在Spring Bean销毁时忘记关闭线程池 —— 实现DisposableBean或@PreDestroy


四、练习篇(10%)

练习1:实现一个优雅关闭的线程池工具类

要求:

练习2:线程池监控Dashboard

编写程序,每隔1秒打印线程池的:

练习3:动态线程池实验

创建核心线程数为2、最大线程数为4的线程池。

练习4:源码追踪ctl变化

在execute()、addWorker()、runWorker()、getTask()、processWorkerExit()中

标注ctl的每一次CAS操作,画出ctl值从创建到线程退出的完整变化时间线。