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 | 延迟执行 | 定时任务 |
任务被拒绝的条件:队列满 且 线程数=maximumPoolSize
1. AbortPolicy(默认)
→ 抛出 RejectedExecutionException
→ 适用:需要感知被拒绝的场景
2. CallerRunsPolicy
→ 由提交任务的线程自己执行该任务
→ 适用:不想丢弃任务,可以接受提交线程被阻塞
3. DiscardPolicy
→ 静默丢弃,不抛异常
→ 适用:可以容忍任务丢失(如日志采集)
4. DiscardOldestPolicy
→ 丢弃队列头(最早提交的)任务,重新提交当前任务
→ 适用:新任务优先级高于旧任务
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本身就是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); // 线程退出处理
}
}
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
// 阿里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。
1. 画出execute()的完整流程图,标注每一步的判断条件。
2. 一个线程池core=2, max=4, queue容量=3,依次提交7个任务,哪些由核心线程执行?哪些入队?哪些由非核心线程执行?哪个被拒绝?
3. 编写代码:创建自定义线程池,设置自定义ThreadFactory(线程名带业务前缀),使用CallerRunsPolicy拒绝策略。
4. 分析getTask()源码:当allowCoreThreadTimeOut=true时,核心线程和非核心线程的行为有何区别?
5. 设计题:一个电商系统,有订单创建(CPU密集)和库存查询(IO密集)两种任务,如何分别配置线程池?