定位:你天天用线程池,配置参数也背过。但面试官问"ctl的高3位是什么""execute()方法中什么情况下直接拒绝""Worker为什么继承AQS""getTask()怎么实现超时退出",你答不精确。本节专治这个gap。
// 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
- 状态只能从小到大变化(数值上),不能回退
// 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)
// 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,可能创建替代线程)
| 策略 | 行为 | 适用场景 |
|---|---|---|
| AbortPolicy | 抛RejectedExecutionException | 默认策略,适合需要感知任务丢失的场景 |
| CallerRunsPolicy | 由提交任务的线程自己执行 | 限流降级,不丢任务 |
| DiscardPolicy | 静默丢弃 | 可容忍任务丢失 |
| DiscardOldestPolicy | 丢弃队列头(最老的任务),重新提交 | 优先处理新任务 |
CPU密集型任务:
线程数 = CPU核心数 + 1
(+1是为了在某个线程偶尔因为页缺失等原因暂停时,额外线程能利用CPU)
IO密集型任务:
线程数 = CPU核心数 × (1 + W/C)
W = 等待时间,C = 计算时间
经验值:CPU核心数 × 2 ~ CPU核心数 × 10
生产环境的实际做法:
不要用公式硬算,先用合理值上线,然后通过监控指标动态调整
关键指标:活跃线程数、队列长度、完成任务数、拒绝次数
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;
}
}
);
}
}
/**
* 自定义拒绝策略:记录日志 + 降级处理
*/
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() { /* 日志上报等非关键任务 */ }
}
}
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);
}
}
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);
}
}
追问链:
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.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.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
要求:
编写程序,每隔1秒打印线程池的:
创建核心线程数为2、最大线程数为4的线程池。
在execute()、addWorker()、runWorker()、getTask()、processWorkerExit()中
标注ctl的每一次CAS操作,画出ctl值从创建到线程退出的完整变化时间线。