'# 【JavaEE精炼宝库】多线程线程池
一、背景与问题
在JavaEE开发中，多线程是提升系统吞吐量的核心手段之一。然而，直接创建线程存在诸多问题：线程创建和销毁的高昂代价、线程资源竞争导致的性能瓶颈、线程阻塞带来的资源浪费。为解决这些问题，Java提供了线程池机制，通过资源复用、任务调度和队列管理，实现对线程资源的高效利用。
典型的业务场景包括：
- HTTP请求处理（Spring MVC、Servlet等框架）
- 异步任务处理（如日志记录、邮件发送）
- 数据处理（如批处理、缓存刷新）
- 高并发场景（如秒杀系统、实时计算）
二、基本原理
1. 线程池核心组件
线程池由以下核心组件构成：
1.1 线程池核心参数
public class ThreadPoolExecutor extends AbstractExecutorService {
final int corePoolSize; // 核心线程数
final int maximumPoolSize; // 最大线程数
final long keepAliveTime; // 线程空闲超时时间
final BlockingQueue<Runnable> workQueue; // 任务队列
final RejectedExecutionHandler handler; // 拒绝策略
}1.2 线程池运行流程
- 任务提交时，先尝试创建新线程（核心线程数未满）
- 如果核心线程已满，将任务加入工作队列
- 如果工作队列满，尝试创建非核心线程（最大线程数未满）
- 如果仍无法创建，执行拒绝策略
2. 线程池状态机
线程池有5种状态：
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int RUNNING = -1 << 1;
private static final int SHUTDOWN = -1 << 2;
private static final int STOP = -1 << 3;
private static final int TERMINATED = -1 << 4;
private static final int ALL_STATES = RUNNING + SHUTDOWN + STOP + TERMINATED;3. 任务调度策略
- 核心线程：始终保留的线程，即使空闲
- 非核心线程：超时后自动回收
- 工作队列：支持多种队列类型（LinkedBlockingQueue、SynchronousQueue等）
三、环境准备
开发环境：
- JDK 1.8+
- IDE：IntelliJ IDEA 或 Eclipse
- 开发语言：Java
- 依赖库（如需）：Spring Boot 2.x
四、核心实现
1. 线程池创建方式
1.1 基础线程池
ExecutorService executor = Executors.newFixedThreadPool(5);1.2 可缓存线程池
ExecutorService executor = Executors.newCachedThreadPool();1.3 自定义线程池
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2, // corePoolSize
5, // maximumPoolSize
60, // keepAliveTime
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100), // 工作队列
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);2. 任务提交与执行
2.1 提交任务
executor.execute(() -> {
System.out.println("Task executed by " + Thread.currentThread().getName());
});2.2 提交带返回值任务
Future<String> future = executor.submit(() -> {
return "Task result";
});2.3 提交带参数任务
executor.submit((String param) -> {
System.out.println("Processing param: " + param);
}, "testParam");3. 线程池关闭
3.1 正常关闭
executor.shutdown(); // 等待任务完成3.2 强制关闭
executor.shutdownNow(); // 立即终止所有任务五、完整案例
1. HTTP请求处理案例
1.1 业务需求
模拟处理100个并发HTTP请求，每个请求执行耗时任务
1.2 代码实现
public class ThreadPoolExample {
private static final int CORE_POOL_SIZE = 5;
private static final int MAX_POOL_SIZE = 10;
private static final int QUEUE_CAPACITY = 100;
private static final long KEEP_ALIVE = 60L;
public static void main(String[] args) {
ThreadPoolExecutor executor = new ThreadPoolExecutor(
CORE_POOL_SIZE,
MAX_POOL_SIZE,
KEEP_ALIVE,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(QUEUE_CAPACITY),
new ThreadPoolExecutor.CallerRunsPolicy()
);
for (int i = 0; i < 100; i++) {
final int taskId = i;
executor.submit(() -> {
try {
Thread.sleep(100); // 模拟耗时操作
System.out.println("Task " + taskId + " executed by " + Thread.currentThread().getName());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println("Task " + taskId + " interrupted");
}
});
}
executor.shutdown();
try {
if (!executor.awaitTermination(1, TimeUnit.MINUTES)) {
executor.shutdownNow();
}
} catch (InterruptedException e) {
executor.shutdownNow();
Thread.currentThread().interrupt();
}
}
}1.3 关键点分析
- 使用LinkedBlockingQueue作为工作队列
- 设置合理的线程池参数（核心线程数5，最大线程数10）
- 处理异常和中断信号
- 正确关闭线程池
六、源码解析
1. ThreadPoolExecutor核心逻辑
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (addWorker(command, true))
return;
if (runStateOf(ctl) == RUNNING &&
workQueue.offer(command)) {
if (runStateOf(ctl) != RUNNING ||
!compareAndIncrementWorkerCount(1))
return;
} else if (!compareAndIncrementWorkerCount(1)) {
reject(command);
}
}2. 线程池状态转换
private void runWorker(Worker w) {
Runnable task = w.firstTask;
boolean finished = false;
while (task != null || (task = getTask()) != null) {
task.run();
task = null;
}
finished = true;
// 状态转换逻辑
if (interrupted)
Thread.currentThread().interrupt();
}七、进阶使用
1. 异步编程
CompletableFuture.supplyAsync(() -> {
return fetchData();
}).thenApply(data -> process(data))
.thenAccept(result -> saveResult(result))
.exceptionally(ex -> {
log.error("Error occurred", ex);
return null;
});2. 线程池参数调优
| 参数 | 说明 | 建议值 |
|---|---|---|
| corePoolSize | 核心线程数 | 通常为CPU核心数*2 |
| maximumPoolSize | 最大线程数 | 根据业务需求调整 |
| keepAliveTime | 空闲线程存活时间 | 通常设置为60s |
| queueCapacity | 工作队列容量 | 需根据系统内存和任务类型调整 |
3. 线程池监控
ThreadPoolExecutor executor = ...;
System.out.println("Pool Size: " + executor.getPoolSize());
System.out.println("Active Threads: " + executor.getActiveCount());
System.out.println("Task Count: " + executor.getTaskCount());
System.out.println("Completed Tasks: " + executor.getCompletedTaskCount());八、性能与工程实践
1. 性能优化策略
1.1 任务分片
List<Runnable> tasks = splitLargeTaskIntoSmallerTasks();
for (Runnable task : tasks) {
executor.submit(task);
}1.2 任务优先级
PriorityBlockingQueue<Runnable> queue = new PriorityBlockingQueue<>();
queue.offer(new PriorityTask(1, "high"));
queue.offer(new PriorityTask(2, "normal"));1.3 资源隔离
// 为不同业务模块创建独立线程池
ExecutorService httpPool = ...;
ExecutorService dbPool = ...;2. 异常处理机制
executor.submit(() -> {
try {
doSomething();
} catch (Exception e) {
log.error("Task failed", e);
}
});3. 安全风险防范
3.1 线程安全
ThreadLocal<Session> session = ThreadLocal.withInitial(() -> new Session());3.2 资源竞争
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
// critical section
} finally {
lock.unlock();
}九、常见问题与踩坑
1. 常见错误
1.1 线程池未关闭
// 错误示例
ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> {
// 任务逻辑
});问题：任务执行完成后线程池未关闭，导致资源泄漏
解决：添加关闭逻辑
executor.shutdown();1.2 队列容量不足
// 错误示例
new LinkedBlockingQueue<>(10); // 设置过小的队列容量问题：任务队列快速填满，导致线程池创建大量线程
解决：根据业务需求调整队列容量
2. 性能问题
2.1 线程饥饿
// 错误配置
new ThreadPoolExecutor(2, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<>(100));问题：核心线程数过少，导致任务堆积
优化：增加corePoolSize
2.2 阻塞队列满
// 错误配置
new LinkedBlockingQueue<>(100); // 未设置合适的队列容量问题：任务队列满后触发拒绝策略
优化：监控队列大小，动态调整容量
十、最佳实践
1. 推荐方案
1.1 标准线程池配置
ThreadPoolExecutor executor = new ThreadPoolExecutor(
Runtime.getRuntime().availableProcessors() * 2, // 核心线程数
Runtime.getRuntime().availableProcessors() * 4, // 最大线程数
60, // 空闲线程存活时间
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000), // 任务队列
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);1.2 任务分类处理
// 短时任务线程池
ExecutorService shortTaskPool = ...;
// 长时任务线程池
ExecutorService longTaskPool = ...;2. 推荐做法
2.1 使用CompletableFuture进行链式调用
CompletableFuture.supplyAsync(() -> fetchData())
.thenApply(data -> process(data))
.thenAccept(result -> saveResult(result))
.exceptionally(ex -> {
log.error("Error occurred", ex);
return null;
});2.2 使用线程池监控
ScheduledExecutorService monitor = Executors.newScheduledThreadPool(1);
monitor.scheduleAtFixedRate(() -> {
System.out.println("Pool Size: " + executor.getPoolSize());
System.out.println("Active Threads: " + executor.getActiveCount());
System.out.println("Task Count: " + executor.getTaskCount());
}, 1, 1, TimeUnit.MINUTES);十一、总结
线程池是Java多线程编程的核心组件，其核心原理基于任务调度、资源复用和状态管理机制。在实际开发中，需要根据业务场景选择合适的线程池配置，合理设置核心参数，并注意异常处理和资源管理。通过合理使用线程池，可以显著提升系统性能和稳定性，但同时也需要警惕线程饥饿、资源竞争等常见问题。本文通过多个代码示例和完整案例，深入解析了线程池的实现原理和使用技巧，为开发者提供了实用的指导。在实际项目中，建议结合监控机制和动态调整策略，持续优化线程池配置，以应对不同的业务需求。