1..5java面试题：线程池

线程池是 Java 面试中必考且最能拉开差距的知识点。老练的 Java 工程师不仅能讲清楚参数，还能结合源码执行流程、生产调优经验、监控与坑点进行深入阐述。下面我用“核心原理 → 参数拆解 → 工作流程 → 实战案例 → 调优与监控 → 常见陷阱”这条线，帮你彻底吃透。

一、为什么必须用线程池？

• 降低资源消耗：复用已创建的线程，减少线程创建、销毁的开销。
• 提高响应速度：任务到达时，无需等待线程创建即可立即执行。
• 提高线程的可管理性：统一分配、监控和调优，防止无限制创建线程导致 OOM。
• 提供更强大的执行控制：执行、排队、拒绝策略、定时执行等。

二、线程池的核心构造参数（ThreadPoolExecutor）

publicThreadPoolExecutor(intcorePoolSize,// 核心线程数intmaximumPoolSize,// 最大线程数longkeepAliveTime,// 空闲线程存活时间TimeUnitunit,// 时间单位BlockingQueue<Runnable>workQueue,// 任务队列ThreadFactorythreadFactory,// 线程工厂RejectedExecutionHandlerhandler)// 拒绝策略

2.1 核心参数详解

• corePoolSize：常驻线程数，即使空闲也不回收（除非allowCoreThreadTimeOut(true)）。
• maximumPoolSize：线程池允许的最大线程数。
  线程数 = core + 当队列满后额外创建的线程，但总量 ≤ max。
• keepAliveTime + unit：超出 core 的线程如果空闲超过此时间，会被回收。
• workQueue：存储等待执行的任务，是线程池吞吐量的关键。
• threadFactory：自定义线程命名、守护、优先级等，便于监控排错。
• handler：当线程数到达 max 且队列满时，对新任务的拒绝策略。

三、线程池的工作流程（源码级理解）

当提交一个任务execute(Runnable command)时：

1. 当前线程数 < corePoolSize
   → 直接创建新线程执行任务（即使有空闲核心线程也会优先创建达到 core）。
2. 当前线程数 ≥ corePoolSize
   → 尝试将任务放入 workQueue 排队。
3. 队列已满
   → 创建新线程（非 core）执行任务，直到达到 maximumPoolSize。
4. 线程数 = max 且队列满
   → 执行拒绝策略。

面试官追问细节：

• 为什么核心线程满了不立即创建非核心线程，而是先入队？
  答：为了缓冲突发流量，减少线程创建销毁的开销，除非队列设定为容量极小的（如 SynchronousQueue）则不等。
• 什么时候会回收非核心线程？
  答：当getPoolSize() > corePoolSize且空闲超过keepAliveTime，回收直到线程数回到 core。

四、阻塞队列选型与实战案例

4.1 常见队列对比

血泪教训：
Executors.newFixedThreadPool(10)底层用的是LinkedBlockingQueue无界队列，队列无限增长会 OOM。所以生产严禁直接使用 Executors 的四个工厂方法。

4.2 案例一：自定义线程池（安全高效）

ThreadPoolExecutorpool=newThreadPoolExecutor(4,// core8,// max60L,TimeUnit.SECONDS,// 空闲回收newArrayBlockingQueue<>(200),// 有界队列，防止 OOMnewThreadFactory(){privatefinalAtomicIntegercount=newAtomicInteger(1);@OverridepublicThreadnewThread(Runnabler){Threadt=newThread(r,"order-pool-"+count.getAndIncrement());t.setDaemon(false);// 非守护，确保任务执行完returnt;}},newThreadPoolExecutor.CallerRunsPolicy()// 拒绝策略：交给主线程执行，防止丢任务);

五、拒绝策略与场景选择

案例：自定义拒绝策略 + 告警

publicclassAlertRejectedHandlerimplementsRejectedExecutionHandler{@OverridepublicvoidrejectedExecution(Runnabler,ThreadPoolExecutorexecutor){log.error("线程池任务被拒绝，当前活跃线程: {}, 队列大小: {}",executor.getActiveCount(),executor.getQueue().size());// 尝试重新入队列或降级到 MQ// 如果仍失败则丢弃或抛异常}}

六、如何合理设置线程数？

6.1 经典公式

• CPU 密集型：线程数 = CPU 核心数 + 1
  例：加密解密、复杂计算。
• I/O 密集型：线程数 = CPU 核心数 * 2 或
  线程数 = CPU核心数 * (1 + 平均等待时间/平均处理时间)
  例：数据库查询、网络调用。
• 混合型：拆分成两个线程池，根据任务耗时比例分配。

6.2 实际案例

在订单处理微服务中，既有 CPU 密集的规则计算，也有大量 DB 和远程调用。
我们拆分两个池：

• 计算池：core = Ncpu,max = Ncpu+2,SynchronousQueue。
• 业务池：core = 10,max = 50,ArrayBlockingQueue(500)，处理大部分 I/O 操作。

最终都需要压测验证，公式只是起点。

七、线程池的监控（生产必备）

7.1 指标采集

通过ThreadPoolExecutor提供的 getter 方法暴露给 Prometheus 或日志。

publicvoidprintPoolStats(ThreadPoolExecutorpool){log.info("核心线程数: {}, 最大线程数: {}, 当前线程数: {}, 活跃线程数: {}, "+"队列中任务数: {}, 已完成任务数: {}, 拒绝任务数: {}",pool.getCorePoolSize(),pool.getMaximumPoolSize(),pool.getPoolSize(),pool.getActiveCount(),pool.getQueue().size(),pool.getCompletedTaskCount(),// 需要自定义包装才能获取拒绝计数);}

7.2 监控指标面板

• 队列积压：队列中等待任务数持续上升，说明消费能力不足，需扩容。
• 活跃线程占比：长期接近 max，且队列不空，考虑增加 max 或提升机器。
• 拒绝次数：发生拒绝说明线程池容量不足或下游出了问题。

7.3 实战案例：动态调整线程池

使用 Apollo/Nacos 等配置中心动态更新 core/max，结合setCorePoolSize()和setMaximumPoolSize()实时生效。

八、线程池的优雅关闭

publicvoidshutdownGracefully(ThreadPoolExecutorpool){pool.shutdown();// 不再接收新任务，已提交的任务继续执行try{if(!pool.awaitTermination(60,TimeUnit.SECONDS)){pool.shutdownNow();// 尝试中断所有任务if(!pool.awaitTermination(30,TimeUnit.SECONDS)){log.error("线程池未关闭成功，部分任务可能丢失");}}}catch(InterruptedExceptione){pool.shutdownNow();Thread.currentThread().interrupt();}}

注意：shutdownNow不保证能停止正在执行的任务，只是尝试中断，业务代码需响应中断。

九、常见陷阱与血泪史

1. 用 Executors 创建线程池导致 OOM
   newFixedThreadPool/newSingleThreadExecutor无界队列，newCachedThreadPool最大线程数为Integer.MAX_VALUE，都危险。
2. 线程池中线程的异常被吞掉
   execute提交的Runnable异常会导致线程消亡，任务丢失，必须用submit+Future.get()或自定义UncaughtExceptionHandler。

   t.setUncaughtExceptionHandler((thread,ex)->log.error("线程异常",ex));

3. submit后不get异常被吞
   submit返回的Future，如果不调用get且任务抛出异常，你完全不知道。
4. 线程池里用 ThreadLocal
   线程复用导致值污染，必须在任务结束时remove()。
5. tomcat / web 容器共享线程池误区
   不要随意使用 servlet 容器线程池处理长耗时任务，应自定义线程池剥离。

十、面试串联话术（建议背诵）

“线程池的核心是一个ThreadPoolExecutor，我理解它的工作流程是优先创建核心线程、满核心入队列、队列满开最大线程、最后拒绝。生产上我绝对不用Executors的快捷方法，而是用ArrayBlockingQueue做有界缓冲、自定义ThreadFactory命名线程、CallerRunsPolicy或自定义拒绝策略保证任务不丢失。

线程数设置上，CPU 密集型用CPU核数+1，I/O 密集型适当放大并压测验证。监控方面，我会定期采集队列大小、活跃线程数、拒绝次数到 Prometheus 并配置告警。

实际项目中我遇到过因LinkedBlockingQueue无界导致 OOM 的事故，后来全部替换为有界队列并动态调整参数。也踩过submit异常被吞、ThreadLocal残留的坑，所以现在任务异常全部捕获记录，线程工厂设置UncaughtExceptionHandler，并在 finally 块清理ThreadLocal。”

这套话术结合了理论、源码流程、调优和真坑，能让面试官确认你是真正的线程池专家。
针对Java（java.util.concurrent包）的标准实现，线程池的核心参数和创建方式如下。

⚙️ 核心参数（共7个）

ThreadPoolExecutor的构造函数包含以下7个核心参数：

1. corePoolSize（核心线程数）：线程池中一直保持存活的线程数量（即使空闲）。如果允许超时，核心线程也可能被回收。
2. maximumPoolSize（最大线程数）：线程池中允许的最大线程数量。
3. keepAliveTime（存活时间）：当实际线程数超过核心线程数时，多余的空闲线程在被终止前等待新任务的最大时间。
4. unit（时间单位）：keepAliveTime的时间单位（如TimeUnit.SECONDS）。
5. workQueue（工作队列）：用于存储等待执行任务的阻塞队列。
   • 关键联动：当核心线程都在忙时，新任务会进入队列。只有当队列填满后，才会继续创建新线程直到maximumPoolSize。
6. threadFactory（线程工厂）：用于创建新线程的工厂，通常用于设置线程名称、优先级或守护进程状态。默认使用Executors.defaultThreadFactory()。
7. rejectedExecutionHandler（拒绝策略）：当线程池已关闭，或队列已满且线程数已达到最大值时，对新任务采取的处理策略。
   • 内置策略：AbortPolicy（默认，抛异常）、CallerRunsPolicy（调用者运行）、DiscardPolicy（静默丢弃）、DiscardOldestPolicy（丢弃最老任务）。

🚀 如何创建线程池

通常推荐直接使用ThreadPoolExecutor构造方法，而不是使用Executors工具类（后者容易导致OOM）。

1. 推荐方式：自定义参数（生产环境标配）

importjava.util.concurrent.*;publicclassThreadPoolDemo{publicstaticvoidmain(String[]args){// 1. 创建线程池实例ThreadPoolExecutorexecutor=newThreadPoolExecutor(5,// corePoolSize10,// maximumPoolSize60L,// keepAliveTimeTimeUnit.SECONDS,// unitnewArrayBlockingQueue<>(100),// workQueue（有界队列）Executors.defaultThreadFactory(),// threadFactorynewThreadPoolExecutor.AbortPolicy()// rejectionHandler);// 2. 提交任务（这是“用线程池创建线程”执行任务的标准方式）for(inti=0;i<15;i++){inttaskId=i;executor.execute(()->{System.out.println("线程 "+Thread.currentThread().getName()+" 执行任务："+taskId);// 模拟业务逻辑});}// 3. 关闭线程池（不再接收新任务）executor.shutdown();}}

2. 快捷方式：Executors工具类（仅限特定场景）

虽然不推荐全局使用，但了解其底层参数有助于理解：

• Executors.newFixedThreadPool(5)：固定线程数。corePoolSize=maxPoolSize=5，队列为无界的LinkedBlockingQueue（可能导致内存溢出）。
• Executors.newCachedThreadPool()：缓存线程池。corePoolSize=0，maxPoolSize=Integer.MAX_VALUE，队列为SynchronousQueue（线程数可能无限增长）。
• Executors.newSingleThreadExecutor()：单线程池。corePoolSize=maxPoolSize=1，无界队列。

⚠️ 核心避坑指南

1. 队列与最大线程数的联动：请务必记住规则——只有当workQueue满了，才会触发corePoolSize向maximumPoolSize扩容。因此，如果使用无界队列（如默认的LinkedBlockingQueue），maximumPoolSize参数将形同虚设。
2. 合理设置拒绝策略：生产环境慎用AbortPolicy（默认抛异常可能中断业务流程），通常建议使用CallerRunsPolicy或自定义策略实现削峰填谷。
3. 线程命名：强烈建议自定义ThreadFactory设置带业务前缀的线程名称（如order-pool-thread-1），以便排查问题。

如果你想深入了解如何根据CPU密集型和IO密集型任务来推算具体参数值，我可以为你详细展开。需要吗？😊