Java 线程池：核心原理、参数配置与实战应用

**定义：**keepAliveTime 表示非核心线程的空闲存活时长，unit 是时间单位（如 TimeUnit.SECONDS）。

**工作机制：**当非核心线程的空闲时间超过 keepAliveTime，该线程会被销毁，直到线程池中的线程数等于 corePoolSize。

扩展：通过 allowCoreThreadTimeOut(true) 可以让核心线程也遵循该存活时间规则。

4. workQueue：任务阻塞队列

**定义：**用于存放等待执行的任务的阻塞队列，必须是 BlockingQueue 的实现类。

常用队列类型：

5. threadFactory：线程工厂

**定义：**用于创建线程的工厂类，实现 ThreadFactory 接口，默认使用 Executors.defaultThreadFactory()。

核心作用：

• 统一设置线程的名称、优先级、是否为守护线程等属性，便于日志排查和问题定位。
• 自定义线程工厂示例：

ThreadFactory customThreadFactory = new ThreadFactory() {
    private final AtomicInteger count = new AtomicInteger(1);
    @Override
    public Thread newThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.setName("custom-thread-" + count.getAndIncrement());
        thread.setPriority(Thread.NORM_PRIORITY);
        return thread;
    }
};

6. handler：拒绝策略

**定义：**当任务队列已满且线程数达到 maximumPoolSize 时，线程池对新提交任务的处理策略，实现 RejectedExecutionHandler 接口。

JDK 默认提供 4 种拒绝策略：

五、线程池的核心工作流程

线程池处理任务的流程遵循核心线程→任务队列→非核心线程→拒绝策略的顺序，具体步骤如下：

1. 当提交一个新任务时，线程池首先判断当前线程数是否小于 corePoolSize：
   • 若是，创建核心线程执行任务；
   • 若否，进入下一步。
2. 判断任务队列是否已满：
   • 若未满，将任务放入队列等待执行；
   • 若已满，进入下一步。
3. 判断当前线程数是否小于 maximumPoolSize：
   • 若是，创建非核心线程执行任务；
   • 若否，触发拒绝策略处理任务。

核心流程示意图：

六、线程池的实战应用

生产环境中，不推荐使用 Executors 工具类创建线程池（如 newFixedThreadPool 使用无界队列，可能导致内存溢出；newCachedThreadPool 最大线程数为 Integer.MAX_VALUE，可能创建大量线程），而是通过 ThreadPoolExecutor 自定义线程池，精准控制参数。

1. 自定义线程池案例：处理高并发订单任务

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 自定义线程池：处理高并发订单任务
 */
public class OrderThreadPoolDemo {
    // 自定义线程工厂
    private static final ThreadFactory ORDER_THREAD_FACTORY = new ThreadFactory() {
        private final AtomicInteger threadCount = new AtomicInteger(1);
        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName("order-handle-thread-" + threadCount.getAndIncrement());
            thread.setDaemon(false); // 非守护线程
            thread.setPriority(Thread.NORM_PRIORITY);
            return thread;
        }
    };

    // 自定义拒绝策略：记录日志 + 抛出异常
    private static final RejectedExecutionHandler ORDER_REJECT_HANDLER = (r, executor) -> {
        System.out.println("任务" + r.toString() + "被拒绝，线程池状态：" +
                "核心线程数=" + executor.getCorePoolSize() +
                ",最大线程数=" + executor.getMaximumPoolSize() +
                ",活跃线程数=" + executor.getActiveCount() +
                ",任务队列数=" + executor.getQueue().size());
        throw new RejectedExecutionException("订单任务处理过载，任务被拒绝");
    };

    // 初始化线程池
    private static final ThreadPoolExecutor ORDER_THREAD_POOL = new ThreadPoolExecutor(
            5, // 核心线程数：CPU 核心数*2（假设 CPU 为 4 核，可根据实际调整）
            10, // 最大线程数：核心线程数*2
            60, // 非核心线程空闲存活时间：60 秒
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(100), // 有界任务队列：容量 100
            ORDER_THREAD_FACTORY,
            ORDER_REJECT_HANDLER
    );

    // 订单处理任务
    static class OrderHandleTask implements Runnable {
        private final String orderId;
        public OrderHandleTask(String orderId) {
            this.orderId = orderId;
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " 处理订单：" + orderId);
            try {
                // 模拟订单处理耗时
                Thread.sleep(500);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
        @Override
        public String toString() {
            return "OrderHandleTask{" + "orderId='" + orderId + '\'' + '}';
        }
    }

    public static void main(String[] args) {
        try {
            // 提交 150 个订单任务，测试线程池处理能力
            for (int i = 1; i <= 150; i++) {
                ORDER_THREAD_POOL.submit(new OrderHandleTask("ORDER_" + i));
            }
        } finally {
            // 关闭线程池：等待所有任务执行完毕后关闭
            ORDER_THREAD_POOL.shutdown();
            try {
                // 等待线程池关闭，超时时间 10 秒
                if (!ORDER_THREAD_POOL.awaitTermination(10, TimeUnit.SECONDS)) {
                    // 超时后强制关闭
                    ORDER_THREAD_POOL.shutdownNow();
                }
            } catch (InterruptedException e) {
                ORDER_THREAD_POOL.shutdownNow();
            }
        }
    }
}

2. 线程池参数配置建议

线程池参数的配置需要结合任务类型和硬件资源，核心参考公式如下：

• **CPU 密集型任务（如数据计算）：**线程数 = CPU 核心数 + 1，减少 CPU 上下文切换的开销。
• **IO 密集型任务（如文件读写、网络请求）：**线程数 = CPU 核心数 * 2 或 CPU 核心数 / (1 - 阻塞系数)（阻塞系数通常为 0.8~0.9），充分利用 CPU 资源。
• 任务队列：优先使用有界队列，避免无界队列导致的内存溢出。
• **拒绝策略：**根据业务需求选择，核心任务推荐 AbortPolicy（快速失败），非核心任务推荐 CallerRunsPolicy 或 DiscardOldestPolicy。

七、线程池的生命周期

线程池的生命期分为 RUNNING→SHUTDOWN→STOP→TIDYING→TERMINATED 五个状态，核心管理方法如下：

• **shutdown()：**平缓关闭线程池，不再接收新任务，但会执行完任务队列中的所有任务。
• **shutdownNow()：**强制关闭线程池，不再接收新任务，尝试中断正在执行的任务，并清空任务队列。
• **awaitTermination(long timeout, TimeUnit unit)：**等待线程池关闭，超时返回 false，常用于判断线程池是否已完全关闭。

**核心注意点：**线程池使用完毕后必须关闭，否则核心线程会一直存活，导致 JVM 无法正常退出。

八、常见误区与避坑指南

• **误区 1：**使用 Executors.newCachedThreadPool() 处理大量任务，导致创建大量线程，引发 OutOfMemoryError。**纠正：**自定义线程池，设置合理的 maximumPoolSize 和有界队列。
• **误区 2：**任务队列设置过大，导致线程池一直使用核心线程，非核心线程从未被创建，无法发挥线程池的并发优势。**纠正：**根据任务并发量合理设置队列大小，让任务队列满时能触发非核心线程的创建。
• **误区 3：**忘记关闭线程池，导致 JVM 进程无法退出。**纠正：**使用 shutdown() 或 shutdownNow() 关闭线程池，搭配 awaitTermination() 确保任务执行完毕。
• **误区 4：**认为线程池的线程数越多，性能越高。**纠正：**线程数超过 CPU 处理能力时，会引发频繁的上下文切换，反而降低性能。

九、总结

本文深入讲解了线程池的核心原理、ThreadPoolExecutor 的 7 个核心参数、工作流程与实战配置。线程池是高并发开发中必不可少的工具，合理配置线程池参数能显著提升程序的性能和稳定性。在实际开发中，应避免使用 Executors 工具类，而是通过 ThreadPoolExecutor 自定义线程池，结合业务场景精准控制核心线程数、最大线程数、任务队列和拒绝策略。