线程池核心参数

很多人问我，线程池参数怎么设置？

我通常反问：你知道线程池有哪些参数吗？

七大参数，每个都有讲究。

七个参数

ThreadPoolExecutor(
    int corePoolSize,              // 核心线程数
    int maximumPoolSize,           // 最大线程数
    long keepAliveTime,           // 空闲存活时间
    TimeUnit unit,                // 时间单位
    BlockingQueue workQueue,      // 任务队列
    ThreadFactory threadFactory,   // 线程工厂
    RejectedExecutionHandler handler  // 拒绝策略
)

参数关系图

┌─────────────────────────────────────────────────────────────┐
│                       线程池参数关系                            │
│                                                              │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                      任务队列                            │  │
│  │  [task] [task] [task] [task] [task] ...               │  │
│  └──────────────────────────────────────────────────────┘  │
│                           │                                  │
│                           ▼                                  │
│  ┌──────────────────────────────────────────────────────┐  │
│  │                     工作线程池                          │  │
│  │   ┌───┐ ┌───┐ ┌───┐ ┌───┐ ┌───┐                   │  │
│  │   │ T1│ │ T2│ │ T3│ │ T4│ │ T5│  ...              │  │
│  │   └───┘ └───┘ └───┘ └───┘ └───┘                   │  │
│  │   corePoolSize        maximumPoolSize                 │  │
│  └──────────────────────────────────────────────────────┘  │
│                                                              │
│  规则：                                                        │
│  1. 任务数 ≤ corePoolSize → 创建核心线程执行                      │
│  2. 核心线程满 → 任务入队                                         │
│  3. 队列满 & 线程数 < maximumPoolSize → 创建临时线程执行            │
│  4. 队列满 & 线程数 = maximumPoolSize → 触发拒绝策略               │
└─────────────────────────────────────────────────────────────┘

参数详解

1. corePoolSize 核心线程数

线程池中保持活跃的最少线程数量。

// corePoolSize = 5
// 即使线程空闲，也不会被回收（除非设置 allowCoreThreadTimeOut）
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    5,                      // 核心线程数
    10,                     // 最大线程数
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>()
);

2. maximumPoolSize 最大线程数

线程池允许创建的最大线程数量。

// 当任务队列满时，会创建临时线程（直到达到最大线程数）
// 之后触发拒绝策略

3. keepAliveTime 空闲线程存活时间

非核心线程的最大空闲时间。

// 空闲 60 秒后回收临时线程
// 核心线程不受影响（除非 allowCoreThreadTimeOut = true）

4. workQueue 任务队列

用于存放等待执行任务的队列。

// 常用队列类型：
// 1. LinkedBlockingQueue - 无界链表队列
// 2. ArrayBlockingQueue - 有界数组队列
// 3. SynchronousQueue - 同步队列
// 4. PriorityBlockingQueue - 优先级队列

5. threadFactory 线程工厂

创建线程的工厂。

ThreadFactory factory = new ThreadFactory() {
    private AtomicInteger count = new AtomicInteger(1);
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setName("MyPool-Thread-" + count.getAndIncrement());
        t.setDaemon(false);  // 非守护线程
        return t;
    }
};

6. handler 拒绝策略

当任务无法被执行时的处理策略。

// JDK 内置 4 种拒绝策略：
// 1. AbortPolicy - 抛出异常（默认）
// 2. CallerRunsPolicy - 由调用线程执行
// 3. DiscardPolicy - 丢弃任务
// 4. DiscardOldestPolicy - 丢弃最老的任务

参数调优

计算密集型

// CPU 密集型：线程数 = CPU核心数
int cpuCores = Runtime.getRuntime().availableProcessors();

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    cpuCores,          // 核心线程数
    cpuCores,          // 最大线程数
    0L, TimeUnit.MILLISECONDS,
    new LinkedBlockingQueue<>()
);

IO 密集型

// IO 密集型：线程数 = CPU核心数 * 2
int cpuCores = Runtime.getRuntime().availableProcessors();
int threads = cpuCores * 2;

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    threads, threads,
    60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1000)
);

总结

参数	说明	建议
corePoolSize	核心线程数	根据任务类型设置
maximumPoolSize	最大线程数	>= corePoolSize
keepAliveTime	空闲存活时间	根据任务类型设置
workQueue	任务队列	建议使用有界队列
threadFactory	线程工厂	自定义线程名
handler	拒绝策略	根据业务选择