知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 56 - 线程池 Executor 核心参数与工作流程 > 导读:本文不重写"手写线程池",也不展开"拒绝策略怎么选",而是聚焦 `ThreadPoolExecutor` 的七个构造参数与任务流转机制本身——每个参数管什么、任务按什么顺序被判定、队列类型如何改写调度行为、以及异常与关闭上的那些坑。适合已经会用线程池、但想把内部规则真正讲清的同学。 ## 一、先建立全局认知 ### Q:创建线程的开销体现在哪?线程池到底解决了哪三个问题? A:结论先行——线程池的核心价值是**把"线程"这种昂贵资源变成可控、可复用的池子**,而不只是"少 new 几个线程"。 先说成本。创建线程要陷入内核态分配栈空间、参与调度器登记,销毁又要回收;线程栈默认约 1MB(受 `-Xss` 控制),一个请求一个线程,峰值一上来内存就先撑不住。这三笔开销叠加,催生了线程池要解决的三件事: 1. **降开销**:线程随取随用、用完归还,把"创建销毁"摊薄成一次性成本。 2. **控数量**:用核心数与最大值给线程总数划出上下界,避免无限创建把系统拖垮。 3. **削峰与排队**:用任务队列把瞬时洪峰缓冲成平稳消费,并统一挂上监控、拒绝、命名等管理能力。 一句话概括:**线程池 = 有界线程 + 任务队列 + 一套调度规则**。理解了这套规则,参数怎么配、为什么会排队、为什么会被拒绝,就都能顺着推出来。 ## 二、理解核心机制 ### Q:七个构造参数分别是什么?各自影响什么、有哪些坑? A:七个参数分三组——"多少个线程""空多久回收""任务放哪、怎么造、装不下怎么办": ```java new ThreadPoolExecutor( 4, // corePoolSize:核心线程数 8, // maximumPoolSize:最大线程数 60L, TimeUnit.SECONDS, // keepAliveTime + unit:空闲存活时间与单位 new ArrayBlockingQueue<>(200), // workQueue:任务队列 Executors.defaultThreadFactory(), // threadFactory:线程工厂 new ThreadPoolExecutor.AbortPolicy() // handler:拒绝策略 ); ``` - **corePoolSize(核心线程数)**:常驻线程数,默认即使空闲也不回收。它决定了"稳态并发",也是线程池最先被填满的一层。 - **maximumPoolSize(最大线程数)**:线程总数的上限,只有队列满了才会向它靠拢。**它必须 ≥ corePoolSize**,否则构造直接抛 `IllegalArgumentException`。 - **keepAliveTime + unit**:**非核心线程**空闲超过这个时长就被回收。坑在于:若想让它对核心线程也生效,得额外开 `allowCoreThreadTimeOut(true)`。 - **workQueue(任务队列)**:核心线程忙碌时新任务的缓冲区。它直接决定"会不会扩容",是七个参数里**对行为影响最大**的一个。 - **threadFactory(线程工厂)**:负责造线程。默认工厂产出 `pool-N-thread-M` 这种无业务含义的名字,线上排查基本靠猜,所以生产一定要自定义。 - **handler(拒绝策略)**:队列满且线程到顶时的兜底。本文只把它当"四段链路的最后一环"带过,具体选型另有专文。  *图:ThreadPoolExecutor 的七大参数与任务的四段判定链路——核心线程、工作队列、非核心线程、拒绝策略,以及队列类型如何改变这条链路。* ### Q:一个任务提交后,完整的判定顺序是什么? A:牢记八个字——**核心、入队、扩容、拒绝**,每一步都是"上一步满了才走下一步":  *图:ThreadPoolExecutor 任务提交流程——核心线程、工作队列、最大线程、拒绝策略的四段判定顺序* ```text execute(task) │ ├─ 线程数 < corePoolSize ? → 新建核心线程执行 ├─ workQueue.offer(task) 成功 ? → 入队等待 ├─ 线程数 < maximumPoolSize ? → 新建非核心线程执行 └─ 否则 → 交给 handler 拒绝 ``` 对应的源码骨架(`execute` 方法,JDK 8,已简化)正是这个顺序: ```java public void execute(Runnable command) { int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { // 1. 核心线程 if (addWorker(command, true)) return; c = ctl.get(); } if (isRunning(c) && workQueue.offer(command)) { // 2. 入队 // 入队后要二次检查:池是否已关闭?线程是否都被回收了? return; } else if (!addWorker(command, false)) { // 3. 扩容到 maximum reject(command); // 4. 拒绝 } } ``` 注意第二步入队成功后有个**二次检查**:因为入队和"发现线程全空闲被回收"可能并发发生,所以要补建一个线程,避免任务躺在队列里没人消费。 ### Q:为什么队列的优先级高于"创建非核心线程"?无界队列为什么会让 maximumPoolSize 失效? A:这不是笔误,而是刻意的设计取舍:**优先用队列缓冲,而不是优先开线程**。开线程要花系统调用和内存,能不开就不开;把任务放进队列几乎零成本。所以线程池的策略是"先榨干已有线程 + 队列,实在装不下才扩容"。 由此推出那条面试高频结论:**如果用无界队列,队列永远不会 `offer` 失败,第三步永远走不到,`maximumPoolSize` 形同虚设,线程数会一直停在 corePoolSize。** 代价是任务在队列里越堆越多、延迟越来越高,最后可能 OOM。`Executors.newFixedThreadPool` 正是踩了这个坑(下文会展开)。 ### Q:线程是怎么被复用的?`runWorker` 的循环长什么样? A:复用的秘密在于——**工作线程本身就是一个死循环**,它不执行完就退出,而是反复从队列取任务: ```java // ThreadPoolExecutor.Worker.run() → runWorker(),已简化 final void runWorker(Worker w) { Runnable task = w.firstTask; // 首次可直接执行构造时带的任务 w.firstTask = null; while (task != null || (task = getTask()) != null) { // 取到任务就执行,执行完继续下一轮 while task.run(); task = null; } } ``` - `getTask()` 会按规则决定用 `take()` 阻塞等待还是 `poll(keepAliveTime)` 超时退出——**超时取出 `null` 时,这个非核心线程就自然结束了**,这就是空闲回收的实现。 - 线程池"池化"的本质,就是让 `Worker` 这个死循环一直活着,省掉反复创建线程的成本。 顺带呼应一下前面 AQS 那篇:`Worker` 自身也是一把基于 AQS 的**独占锁**(`Worker extends AbstractQueuedSynchronizer`)。它不用来保护业务数据,而是用来标记"这个线程是否正在执行任务",`shutdown` 时靠它判断该不该打断线程,是 AQS 复用为"状态标记"的一个巧妙例子。 ### Q:`allowCoreThreadTimeOut` 是干什么的?`execute` 与 `submit` 的异常行为为什么不同? A:两个容易踩的点,分开说。 **其一,`allowCoreThreadTimeOut(true)`**:默认只有非核心线程会被回收,核心线程空闲也常年占着。开启后核心线程空闲超时同样会被回收,适合"流量潮汐明显、平时几乎没任务"的池,能省下常驻线程;代价是流量回来时要重新建线程,有冷启动延迟。 **其二,`execute` 与 `submit` 的异常差异**。`execute(Runnable)` 直接抛异常,任务里未捕获的 `RuntimeException` 会浮到线程的 `UncaughtExceptionHandler`,能被打出来。而 `submit` 返回 `Future`,异常被**封装进 Future 吞掉了**——不调用 `future.get()` 就永远不知道任务炸了: ```java // submit 的异常被吞:任务抛异常,主线程却毫无感知 Future<?> f = pool.submit(() -> { throw new RuntimeException("boom"); }); // 只有 get() 才把异常重新抛出(包成 ExecutionException) try { f.get(); } catch (ExecutionException e) { /* 这里才看得到 boom */ } ``` 所以:**关心异常就用 `execute`,或者用 `submit` 后务必 `get()` 检查结果**。很多"任务静默失败"的线上问题,根源就是 `submit` 了却从不 `get()`。 ## 三、放进真实场景 ### Q:队列类型对调度行为有什么决定性影响? A:因为是"队列优先于扩容",队列的选择几乎就等于在给线程池定性格: - **LinkedBlockingQueue**:默认无界(容量 `Integer.MAX_VALUE`)。任务全进队列、永不拒绝、线程数恒等于 corePoolSize——**最容易埋雷**,一定要传容量参数变成有界。 - **ArrayBlockingQueue**:有界数组队列。行为最可预测:队列满了会触发扩容、再到拒绝,是生产手动配置的常见选择。 - **SynchronousQueue**:不存储元素的"手递手"队列,`offer` 只在有线程正等着接任务时才成功,否则立即失败——于是任务一来就扩容,天然适合"任务短、要求快响应、可弹性"的场景(`newCachedThreadPool` 就用它)。 - **PriorityBlockingQueue**:按优先级出队,**注意它同样是无界的**,所以要自己控制任务总量,否则一样堆积。 - **DelayQueue**:元素到期才能被取出,用于定时/延迟任务,本质是"延迟调度"而非"削峰"。 一句话记忆:**有界队列 → 会扩容会拒绝;无界队列 → 只排队不扩容。** ### Q:为什么不建议用 `Executors` 工厂方法? A:四个工厂方法各埋了一个坑,本质都是"帮你选了危险默认值": - **`newFixedThreadPool(n)` / `newSingleThreadExecutor()`**:都用了无界 `LinkedBlockingQueue`,任务堆积到内存撑爆,就是上面说的 `maximumPoolSize` 失效问题。 - **`newCachedThreadPool()`**:`maximumPoolSize` 设为 `Integer.MAX_VALUE` 且用 `SynchronousQueue`,任务一多就无限建线程,直接耗尽资源。 - **`newScheduledThreadPool(n)`**:同样是无界队列,堆积延迟任务照样有 OOM 风险。 这正是《阿里巴巴 Java 开发手册》要求"**线程池不允许用 `Executors` 创建,必须手动 `new ThreadPoolExecutor`**"的原因:让七个参数显式写出来,队列有界、最大值可控、线程可命名,风险一眼可见。手动配置的标准写法: ```java ThreadPoolExecutor pool = new ThreadPoolExecutor( 4, 8, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(200), new ThreadFactory() { // 关键:给线程起可辨识的名字 private final AtomicInteger seq = new AtomicInteger(1); @Override public Thread newThread(Runnable r) { return new Thread(r, "order-pool-" + seq.getAndIncrement()); } }, new ThreadPoolExecutor.AbortPolicy()); ``` 自定义线程名是这里最容易被忽视的一点:出问题时 jstack 一眼就能看出是哪个业务池、第几个线程,而默认的 `pool-1-thread-1` 只能靠猜。 ### Q:线程数到底按什么思路设?公式能直接照搬吗? A:思路是"先分任务类型、再给初始值、最后靠压测收敛": ```text CPU 密集型(计算、加解密):核心数 ≈ CPU 核数 + 1,队列可以浅一点 IO 密集型(DB、HTTP 调用):核心数 ≈ CPU 核数 × 2,队列可以深一些 ``` - **CPU 密集型任务几乎不阻塞**,多开线程只会白白增加上下文切换,所以线程数贴着核数走;"+1"是为了在某个线程偶尔缺页或短暂阻塞时仍有线程顶上,避免 CPU 空转。 - **IO 密集型任务大部分时间在等外部响应**,线程可以远多于核数,用"多线程"把等待时间重叠起来,核心数才需要放大。 但要清醒:等待时间与计算时间的比值在生产里很难估准,**上面这些数值只是初始值,最终必须靠压测把"队列积压、活跃线程数、拒绝次数"三个指标调到稳态**,再配合动态调参做线上微调。把公式当标准答案,是参数配置最常见的误区。 ### Q:能不能用一个实验把"核心 → 队列 → 扩容 → 拒绝"跑出来? A:可以。把参数故意调小、任务里 `sleep` 把每一步放大到肉眼可见: ```java // 核心 1、最大 2、队列容量 1:四段链路的边界刚好在 4 个任务内走完 ThreadPoolExecutor pool = new ThreadPoolExecutor( 1, 2, 60L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(1)); for (int i = 1; i <= 4; i++) { final int id = i; try { pool.execute(() -> { System.out.println("任务 " + id + " 在 " + Thread.currentThread().getName() + " 执行"); try { Thread.sleep(2000); } catch (InterruptedException ignore) { } }); System.out.println("任务 " + id + " 提交成功 | poolSize=" + pool.getPoolSize() + " | queue=" + pool.getQueue().size()); } catch (RejectedExecutionException e) { System.out.println("任务 " + id + " 被拒绝!"); } } pool.shutdown(); ``` 预期能观察到四个阶段:任务 1 由新核心线程执行(core=1);任务 2 因核心满而入队(queue=1);任务 3 因队列也满而扩出非核心线程(poolSize=2);任务 4 触发拒绝。**这段代码的价值不在结果,而在把"队列先于扩容"这条反直觉规则变成可观察的事实。** 把队列换成无界 `LinkedBlockingQueue` 再跑一次,就能看到最大线程数失效: ```java // 队列无界:无论提交多少任务,poolSize 都会一直停在 corePoolSize ThreadPoolExecutor pool = new ThreadPoolExecutor( 1, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>()); for (int i = 0; i < 100; i++) { pool.execute(() -> { try { Thread.sleep(3000); } catch (InterruptedException ignore) { } }); } System.out.println("poolSize = " + pool.getPoolSize()); // 恒为 1,maximumPoolSize=10 从未生效 ``` ### Q:怎么优雅关闭线程池?`shutdown` 和 `shutdownNow` 差在哪? A:两者的分水岭是**对已提交任务的态度**:`shutdown()` 不再收新任务,但会让队列里已有的任务跑完;`shutdownNow()` 不再收新任务,同时中断正在执行的线程并返回队列中未执行的任务列表。生产上的标准姿势是"先温和、超时再强硬": ```java pool.shutdown(); // 停止接收新任务 try { if (!pool.awaitTermination(30, TimeUnit.SECONDS)) { pool.shutdownNow(); // 超时还没关完,强制中断 } } catch (InterruptedException e) { pool.shutdownNow(); Thread.currentThread().interrupt(); // 恢复中断标记,交还上层 } ``` 要记住:`shutdownNow` 的中断是**协作式**的——它只给线程打中断标记,任务是否真的停下取决于它有没有响应中断。所以对不可中断的任务,强杀也杀不掉,最终还得靠业务配合。 ## 四、总结与自测 ### Q:面试里怎么答"线程池参数与工作流程"这道题? A:按"参数 → 顺序 → 队列 → 实践"四层递进: 1. **参数**:七个参数分三组,重点说清 `corePoolSize`、`maximumPoolSize`、`workQueue` 三者的配合,以及"maximumPoolSize 必须 ≥ corePoolSize"。 2. **顺序**:核心线程 → 入队 → 扩容到 maximum → 拒绝,并解释**为什么队列优先于扩容**,从而推出"无界队列让 maximumPoolSize 失效"。 3. **队列**:有界队列会扩容会拒绝,无界队列只排队不扩容;不同队列对应不同调度性格。 4. **实践**:不用 `Executors`、手动配置、给线程命名、`submit` 要 `get()`、用 `shutdown + awaitTermination` 优雅关闭。 注意本文刻意不展开拒绝策略选型与手写实现:前者的重点是"满了以后怎么办",后者的重点是"从零造一个池",而这里的重点是"池本身的参数与任务怎么流动",面试时把这层讲透,其余自然能接上。 --- ## 自测 1. 七个构造参数中,哪一个对线程池的运行行为影响最大?为什么说它比 `maximumPoolSize` 更关键? 2. 任务提交的四段判定顺序是什么?为什么"队列"要排在"创建非核心线程"之前?由此推出无界队列的什么后果? 3. 为什么 `submit` 的任务抛异常,不调用 `Future.get()` 就完全感知不到?这与 `execute` 有什么区别? 4. `shutdown()` 与 `shutdownNow()` 的核心区别是什么?为什么说 `shutdownNow()` 的"中断"未必能真正停下任务?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入