Java 线程池详解
线程池是Java并发编程的核心组件，它能高效管理线程生命周期，避免频繁创建销毁线程的开销，提升系统性能和资源利用率。
一、线程池核心优势
- 降低资源消耗：复用已创建的线程，减少线程创建销毁开销
- 提高响应速度：任务到达时可直接使用空闲线程执行
- 提高线程管理性：统一分配、监控和调优线程资源
- 防止资源耗尽：通过队列缓冲和拒绝策略防止系统过载
二、线程池核心实现 - ThreadPoolExecutor
public ThreadPoolExecutor(
int corePoolSize, // 核心线程数
int maximumPoolSize, // 最大线程数
long keepAliveTime, // 非核心线程空闲存活时间
TimeUnit unit, // 时间单位
BlockingQueue<Runnable> workQueue, // 任务队列
ThreadFactory threadFactory, // 线程工厂
RejectedExecutionHandler handler // 拒绝策略
)
核心参数详解
| 参数 | 说明 | 典型值 |
|---|---|---|
corePoolSize | 常驻核心线程数 | CPU密集型：N+1 IO密集型：2N+1 |
maximumPoolSize | 最大线程数 | 建议200~500（根据场景调整） |
keepAliveTime | 非核心线程空闲存活时间 | 60s |
workQueue | 任务阻塞队列 | LinkedBlockingQueueArrayBlockingQueueSynchronousQueue |
handler | 拒绝策略 | AbortPolicyCallerRunsPolicyDiscardPolicyDiscardOldestPolicy |
三、Executors工具类创建的线程池类型
1. FixedThreadPool（固定大小线程池）
ExecutorService fixedPool = Executors.newFixedThreadPool(5);
- 特点：固定核心线程数 = 最大线程数
- 队列：无界
LinkedBlockingQueue - 适用场景：负载较重的服务器
2. CachedThreadPool（可缓存线程池）
ExecutorService cachedPool = Executors.newCachedThreadPool();
- 特点：核心线程数=0，最大线程数=Integer.MAX_VALUE
- 队列：
SynchronousQueue（直接传递队列） - 线程回收：60秒空闲后终止
- 适用场景：大量短生命周期异步任务
3. SingleThreadExecutor（单线程池）
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
- 特点：单工作线程执行
- 队列：无界
LinkedBlockingQueue - 适用场景：顺序执行任务
4. ScheduledThreadPool（定时任务线程池）
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(3);
- 支持定时/周期性任务
- 核心方法：
// 延迟执行 scheduledPool.schedule(task, 5, TimeUnit.SECONDS); // 固定频率执行 scheduledPool.scheduleAtFixedRate(task, 1, 3, TimeUnit.SECONDS); // 固定延迟执行 scheduledPool.scheduleWithFixedDelay(task, 1, 2, TimeUnit.SECONDS);
四、任务队列类型
| 队列类型 | 特性 | 适用场景 |
|---|---|---|
LinkedBlockingQueue | 无界队列（默认容量Integer.MAX_VALUE） | 任务量未知但增长较快 |
ArrayBlockingQueue | 有界队列（固定容量） | 防止资源耗尽 |
SynchronousQueue | 不存储元素的阻塞队列 | 直接传递任务 |
PriorityBlockingQueue | 优先级队列 | 任务需要按优先级处理 |
五、拒绝策略
当线程池饱和（队列满+线程数=max）时触发
-
AbortPolicy（默认策略）
- 抛出
RejectedExecutionException - 保证任务不丢失
- 抛出
-
CallerRunsPolicy
- 由提交任务的线程直接执行
- 降低新任务提交速度
-
DiscardPolicy
- 静默丢弃无法处理的任务
- 可能丢失任务
-
DiscardOldestPolicy
- 丢弃队列中最旧的任务
- 尝试重新提交当前任务
六、线程工厂（ThreadFactory）
自定义线程创建行为：
ThreadFactory customFactory = r -> {
Thread t = new Thread(r);
t.setName("Worker-" + threadCounter.getAndIncrement());
t.setDaemon(false);
t.setPriority(Thread.NORM_PRIORITY);
t.setUncaughtExceptionHandler((th, ex) ->
System.err.println("Uncaught in " + th.getName() + ": " + ex));
return t;
};
七、线程池工作流程
- 提交任务
- 核心线程未满 → 创建新线程执行
- 核心线程已满 → 任务入队列
- 队列已满且线程数<max → 创建非核心线程
- 队列满且线程数=max → 触发拒绝策略
八、线程池监控
通过扩展ThreadPoolExecutor实现监控：
public class MonitorThreadPool extends ThreadPoolExecutor {
// 构造函数...
@Override
protected void beforeExecute(Thread t, Runnable r) {
super.beforeExecute(t, r);
System.out.println("Task start: " + ((TrackedTask)r).getId());
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
super.afterExecute(r, t);
System.out.println("Task completed: " + ((TrackedTask)r).getId());
}
@Override
protected void terminated() {
super.terminated();
System.out.println("ThreadPool terminated");
}
}
关键监控指标：
getPoolSize()：当前线程数getActiveCount()：活动线程数getCompletedTaskCount()：已完成任务数getQueue().size()：队列中任务数
九、最佳实践
1. 线程池大小配置
- CPU密集型：
N_cpu + 1 - IO密集型：
N_cpu * (1 + WT/ST)- WT：等待时间
- ST：计算时间
- 通常：2N_cpu ~ 5N_cpu
2. 避免使用无界队列
// 错误示例（可能导致OOM）
ExecutorService pool = new ThreadPoolExecutor(
5, 10, 60, TimeUnit.SECONDS,
new LinkedBlockingQueue<>() // 无界队列
);
// 正确做法（使用有界队列）
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);
3. 合理设置线程存活时间
// 设置非核心线程空闲30秒后回收
new ThreadPoolExecutor(5, 20, 30, TimeUnit.SECONDS, ...);
4. 自定义拒绝策略
// 自定义拒绝策略：记录日志并重试
RejectedExecutionHandler customHandler = (r, executor) -> {
logger.warn("Task rejected, saving for retry: " + r.toString());
// 保存任务到持久化存储
saveTaskForRetry(r);
};
5. 关闭线程池的正确方式
void shutdownGracefully(ExecutorService pool) {
pool.shutdown(); // 拒绝新任务
try {
if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
pool.shutdownNow(); // 取消正在执行的任务
if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
System.err.println("Thread pool did not terminate");
}
}
} catch (InterruptedException e) {
pool.shutdownNow();
Thread.currentThread().interrupt();
}
}
十、线程池常见问题
1. 任务堆积导致OOM
- 解决方案：使用有界队列 + 合理拒绝策略
2. 线程泄漏
- 场景：任务抛出未捕获异常导致工作线程终止
- 解决方案：使用自定义线程工厂设置UncaughtExceptionHandler
3. 死锁
- 场景：池内任务相互等待
- 解决方案：避免任务间依赖，增大线程池
4. 资源耗尽
- 场景：过多线程竞争有限资源
- 解决方案：使用资源隔离（不同业务用不同线程池）
十一、Spring中的线程池
Spring Boot配置线程池：
@Configuration
public class ThreadPoolConfig {
@Bean("taskExecutor")
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(5);
executor.setMaxPoolSize(10);
executor.setQueueCapacity(100);
executor.setThreadNamePrefix("Spring-Async-");
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
executor.initialize();
return executor;
}
}
使用注解：
@Async("taskExecutor")
public void asyncProcess() {
// 异步处理逻辑
}
总结
Java线程池最佳实践：
- 根据场景选择线程池类型：优先使用
ThreadPoolExecutor自定义 - 合理配置参数：核心线程数、最大线程数、队列容量
- 使用有界队列：防止OOM
- 设置合理拒绝策略：保证业务可靠性
- 添加监控：了解线程池运行状态
- 优雅关闭：确保任务完成和资源释放
对于现代应用，推荐使用更高级的并发工具：
- CompletableFuture：异步编程
- ForkJoinPool：分治任务
- Virtual Threads（Java 19+）：轻量级线程
正确使用线程池能显著提升系统吞吐量和稳定性，是Java高性能应用的基石。
