深入剖析 Java 线程池：原理、使用与优秀实践

public ThreadPoolExecutor(
    int corePoolSize,       // 核心线程数（常驻线程）
    int maximumPoolSize,    // 最大线程数
    long keepAliveTime,     // 空闲线程存活时间
    TimeUnit unit,          // 时间单位
    BlockingQueue<Runnable> workQueue, // 任务队列
    ThreadFactory threadFactory,       // 线程工厂
    RejectedExecutionHandler handler)  // 拒绝策略
1.
2.
3.
4.
5.
6.
7.
8.

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
            2,                      // 核心线程2个
            5,                     // 最大线程5个
            60, TimeUnit.SECONDS,  // 空闲线程存活时间
            new ArrayBlockingQueue<>(10), // 容量10的队列
            Executors.defaultThreadFactory(), // 默认线程工厂
            new ThreadPoolExecutor.AbortPolicy()); // 拒绝策略

        // 提交20个任务
        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() 
                    + " 执行任务：" + taskId);
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown(); // 优雅关闭
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

pool-1-thread-1 执行任务：0
pool-1-thread-2 执行任务：1
pool-1-thread-3 执行任务：11
pool-1-thread-4 执行任务：12
pool-1-thread-5 执行任务：13
（后续任务进入队列或被拒绝）
1.
2.
3.
4.
5.
6.

// 固定大小线程池
ExecutorService fixedPool = Executors.newFixedThreadPool(5);

// 单线程池
ExecutorService singlePool = Executors.newSingleThreadExecutor();

// 缓存线程池
ExecutorService cachedPool = Executors.newCachedThreadPool();

// 调度线程池
ScheduledExecutorService scheduledPool = 
    Executors.newScheduledThreadPool(3);
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();

    int c = ctl.get();
    // 阶段1：核心线程处理
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 阶段2：入队列
    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))
        reject(command); // 执行拒绝策略
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

// 错误示范：使用无界队列
new ThreadPoolExecutor(n, n, 0, TimeUnit.SECONDS, 
    new LinkedBlockingQueue<>());

// 正确做法：使用有界队列+合适拒绝策略
new ThreadPoolExecutor(n, 2*n, 60, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(1000),
    new CustomRejectedPolicy());
1.
2.
3.
4.
5.
6.
7.
8.

// 必须调用shutdown
executor.shutdown();

// 或者使用Hook关闭
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
            executor.shutdownNow();
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
    }
}));
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

public class MonitorThreadPool extends ThreadPoolExecutor {
    // 重写钩子方法
    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        System.out.println("Task start: " + ((Task) r).getId());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        System.out.println("Task complete: " + ((Task) r).getId());
    }

    // 自定义监控方法
    public void printStats() {
        System.out.println("Pool Size: " + this.getPoolSize());
        System.out.println("Active Count: " + this.getActiveCount());
        System.out.println("Queue Size: " + this.getQueue().size());
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

// 使用CompletableFuture实现并行计算
public class ParallelProcessor {
    private final ExecutorService executor = 
        Executors.newWorkStealingPool();

    public Result process(List<Task> tasks) {
        List<CompletableFuture<PartialResult>> futures = tasks.stream()
            .map(task -> CompletableFuture.supplyAsync(
                () -> compute(task), executor))
            .collect(Collectors.toList());

        CompletableFuture<Void> allDone = 
            CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));

        return allDone.thenApply(v -> 
            futures.stream()
                .map(CompletableFuture::join)
                .reduce(new Result(), this::merge))
            .join();
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

// 使用TransmittableThreadLocal解决线程池上下文传递
TransmittableThreadLocal<String> context = new TransmittableThreadLocal<>();

void executeTask() {
    context.set("main-context");
    executor.execute(TtlRunnable.get(() -> {
        System.out.println("Get context: " + context.get());
    }));
}
1.
2.
3.
4.
5.
6.
7.
8.
9.