← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(1小时精讲内容)面试速记卡(考前30秒速看)练习题(自测)学习资料

L03 - 线程池执行原理

本节目标(学完能回答的面试题)

核心知识(1小时精讲内容)

一、ThreadPoolExecutor 7参数(必背)


public ThreadPoolExecutor(
    int corePoolSize,        // ① 核心线程数(即使空闲也不回收,除非allowCoreThreadTimeOut)
    int maximumPoolSize,     // ② 最大线程数(核心+非核心)
    long keepAliveTime,      // ③ 非核心线程空闲存活时间
    TimeUnit unit,           // ④ 时间单位
    BlockingQueue<Runnable> workQueue, // ⑤ 任务队列
    ThreadFactory threadFactory,       // ⑥ 线程工厂(自定义线程名)
    RejectedExecutionHandler handler   // ⑦ 拒绝策略
)

5种常用任务队列:

队列类型特点适用场景
LinkedBlockingQueue无界(默认Integer.MAX_VALUE)Executors.newFixedThreadPool
ArrayBlockingQueue有界需要控制队列长度
SynchronousQueue不存储,直接交付Executors.newCachedThreadPool
PriorityBlockingQueue按优先级排序任务有优先级
DelayQueue延迟执行定时任务

二、4种拒绝策略


任务被拒绝的条件:队列满 且 线程数=maximumPoolSize

1. AbortPolicy(默认)
   → 抛出 RejectedExecutionException
   → 适用:需要感知被拒绝的场景

2. CallerRunsPolicy
   → 由提交任务的线程自己执行该任务
   → 适用:不想丢弃任务,可以接受提交线程被阻塞

3. DiscardPolicy
   → 静默丢弃,不抛异常
   → 适用:可以容忍任务丢失(如日志采集)

4. DiscardOldestPolicy
   → 丢弃队列头(最早提交的)任务,重新提交当前任务
   → 适用:新任务优先级高于旧任务

三、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))  // 创建核心线程执行任务
            return;
        c = ctl.get();
    }

    // 步骤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))
        // 步骤4:线程数 = maximumPoolSize,执行拒绝策略
        reject(command);
}

execute流程图:


┌───────────────────────────────────────────────────────────────┐
│                   execute(task) 执行流程                       │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  提交任务 task                                                │
│     │                                                         │
│     ▼                                                         │
│  线程数 < corePoolSize?                                       │
│     │是                                                       │
│     └──→ 创建核心Worker线程,执行task ──→ 结束                 │
│                                                               │
│     │否                                                       │
│     ▼                                                         │
│  workQueue.offer(task) 入队成功?                              │
│     │是                                                       │
│     ├──→ 双重检查线程池状态                                    │
│     │     ├─ 已关闭 → reject(task)                            │
│     │     └─ 运行中 → 检查是否有工作线程,没有则创建一个空线程  │
│                                                               │
│     │否(队列满)                                             │
│     ▼                                                         │
│  线程数 < maximumPoolSize?                                    │
│     │是                                                       │
│     └──→ 创建非核心Worker线程,执行task ──→ 结束               │
│                                                               │
│     │否(线程数已满)                                         │
│     ▼                                                         │
│  reject(task) → 执行拒绝策略                                  │
│                                                               │
└───────────────────────────────────────────────────────────────┘

四、Worker与runWorker源码


// Worker本身就是AQS的子类(不可重入锁),继承自AbstractQueuedSynchronizer
private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
    final Thread thread;        // Worker对应的线程
    Runnable firstTask;         // 第一个任务(可能为null)
    volatile long completedTasks;

    Worker(Runnable firstTask) {
        setState(-1); // 禁止在runWorker前被中断
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(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 rs = runStateOf(c);

        // 线程池已停止 或 (正在关闭且队列为空) → 返回null(线程退出)
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }

        int wc = workerCountOf(c);
        // 是否需要超时控制
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        // 超时且可以减少线程 → 返回null(线程退出)
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            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;
        }
    }
}

保活机制总结:


核心线程(wc <= corePoolSize 且 allowCoreThreadTimeOut=false):
  → workQueue.take() 阻塞等待,永不过期
  → 这就是核心线程"不会死"的原因

非核心线程(wc > corePoolSize):
  → workQueue.poll(keepAliveTime) 超时等待
  → 超时后返回null → runWorker的while循环结束 → 线程退出
  → 这就是非核心线程"空闲会死"的原因

六、线程池状态流转


线程池状态(存储在ctl的高3位):

  RUNNING    = -1 << 29 = 111...  → 接受新任务,处理队列任务
  SHUTDOWN   =  0 << 29 = 000...  → 不接受新任务,处理队列中的任务
  STOP       =  1 << 29 = 001...  → 不接受新任务,不处理队列,中断进行中的任务
  TIDYING    =  2 << 29 = 010...  → 所有任务终止,workerCount=0
  TERMINATED =  3 << 29 = 011...  → terminated()方法执行完成

状态流转:

  RUNNING ──shutdown()──→ SHUTDOWN ──(队列空且线程全停)──→ TIDYING ──terminated()──→ TERMINATED
     │                                                                                   ↑
     └──────────────shutdownNow()──→ STOP ──(线程全停)──→ TIDYING ──────────────────────┘

// shutdown():优雅关闭
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN);      // 状态改为SHUTDOWN
        interruptIdleWorkers();          // 中断空闲线程(正在执行的不中断)
        onShutdown();                    // 钩子(ScheduledThreadPool使用)
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
}

// shutdownNow():强制关闭
public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP);           // 状态改为STOP
        interruptWorkers();              // 中断所有线程(包括正在执行的)
        tasks = drainQueue();            // 返回队列中未执行的任务
    } finally {
        mainLock.unlock();
    }
    tryTerminate();
    return tasks;
}

七、动态调参(美团实践)

美团技术团队在《Java线程池实现原理及其在美团业务中的实践》中提出了动态调参方案:


// ThreadPoolExecutor提供了运行时修改参数的方法:
public void setCorePoolSize(int corePoolSize);     // 动态修改核心线程数
public void setMaximumPoolSize(int maximumPoolSize); // 动态修改最大线程数
public void setKeepAliveTime(long time, TimeUnit unit);

// 美团实践方案:
// 1. 将线程池参数配置在配置中心(Apollo/Nacos)
// 2. 监听配置变更
// 3. 变更时调用set方法动态调整

// 美团开源的动态线程池:DynamicTp
// GitHub: https://github.com/dromara/dynamic-tp
// 特性:
//   - 基于配置中心动态调整参数
//   - 运行时监控(活跃线程数、队列大小、拒绝次数等)
//   - 告警通知(线程池过载、拒绝次数过多等)
//   - 支持多种配置中心(Nacos/Apollo/Zookeeper)

动态调参注意事项:


setCorePoolSize(newCoreSize) 内部逻辑:
  1. 如果 newCoreSize > oldCoreSize → 立即创建新核心线程
  2. 如果 newCoreSize < oldCoreSize → 多余的核心线程在下次getTask()时会超时退出

注意:newCoreSize 不能大于 maximumPoolSize,否则会被忽略!
所以调整顺序应该是:先调大maximum,再调大core

八、为什么禁止使用Executors创建线程池


// 阿里Java开发手册明确规定:

// 危险!newFixedThreadPool → LinkedBlockingQueue(无界) → OOM
ExecutorService pool1 = Executors.newFixedThreadPool(10);
// 队列长度 = Integer.MAX_VALUE ≈ 21亿,任务堆积会导致OOM

// 危险!newSingleThreadExecutor → 同上,无界队列
ExecutorService pool2 = Executors.newSingleThreadExecutor();

// 危险!newCachedThreadPool → maximumPoolSize = Integer.MAX_VALUE
ExecutorService pool3 = Executors.newCachedThreadPool();
// 可能创建海量线程导致OOM

// 正确做法:手动创建ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    4,                              // corePoolSize
    8,                              // maximumPoolSize
    60, TimeUnit.SECONDS,           // keepAliveTime
    new ArrayBlockingQueue<>(1000),  // 有界队列!
    new ThreadFactory() {            // 自定义线程名
        private final AtomicInteger counter = new AtomicInteger(0);
        public Thread newThread(Runnable r) {
            return new Thread(r, "biz-pool-" + counter.incrementAndGet());
        }
    },
    new ThreadPoolExecutor.CallerRunsPolicy()  // 拒绝策略
);

九、面试追问与回答

Q1: 提交任务时,是先创建线程还是先入队列?

先入队列!当线程数 >= corePoolSize时,任务先进入workQueue,只有队列满时才会创建非核心线程(线程数 < maximumPoolSize)。这和很多人直觉相反。

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

默认不会。但调用allowCoreThreadTimeOut(true)后,核心线程也会在keepAliveTime后超时退出。

Q3: shutdown()和shutdownNow()的区别?

shutdown()不接受新任务但处理完队列中已有任务;shutdownNow()不接受新任务、不处理队列、中断正在执行的任务,并返回未执行的任务列表。

Q4: 线程池中线程异常了会怎样?

如果任务抛出异常且未被捕获,该Worker线程会退出(processWorkerExit),线程池会自动创建新线程替代。但异常不会传播到调用者。建议在任务内部try-catch。

Q5: 如何合理配置线程池大小?

CPU密集型:线程数 = CPU核数 + 1
IO密集型:线程数 = CPU核数 * 2 或 CPU核数 / (1 - 阻塞系数)
实际以压测结果为准,核心线程数可参考 QPS * 平均RT。

面试速记卡(考前30秒速看)

练习题(自测)

1. 画出execute()的完整流程图,标注每一步的判断条件。

2. 一个线程池core=2, max=4, queue容量=3,依次提交7个任务,哪些由核心线程执行?哪些入队?哪些由非核心线程执行?哪个被拒绝?

3. 编写代码:创建自定义线程池,设置自定义ThreadFactory(线程名带业务前缀),使用CallerRunsPolicy拒绝策略。

4. 分析getTask()源码:当allowCoreThreadTimeOut=true时,核心线程和非核心线程的行为有何区别?

5. 设计题:一个电商系统,有订单创建(CPU密集)和库存查询(IO密集)两种任务,如何分别配置线程池?

学习资料