Page cover

Thread Pool

1. 线程池核心概念

Java 通过 Executor 框架（尤其是 ThreadPoolExecutor 类）提供了可配置、可复用的线程管理机制，以避免频繁创建/销毁线程导致的开销，并能在任务激增时更好地控制系统负载。

2. 工作流程与执行顺序

下面以 ThreadPoolExecutor 为例，示意一个典型的任务提交与执行流程：

          ┌────────────────────────────────────────────────────────┐
          │                    提交任务（execute/submit）         │
          └────────────────────────────────────────────────────────┘
                                ▼
                    [当前运行线程数 < corePoolSize ?]
                                ├── Yes --> 创建新线程执行任务
                                ▼  No
                    [工作队列（workQueue）是否已满？]
                                ├── No --> 任务入队
                                ▼  Yes
                [当前运行线程数 < maximumPoolSize ?]
                                ├── Yes --> 创建新线程执行任务
                                ▼  No
          [触发 拒绝策略 (RejectedExecutionHandler)]

解读：

  1. 小于核心线程数（corePoolSize）

    • 直接创建新线程来执行任务，无需排队。

  2. 达到或超过核心线程数

    • 先尝试把任务放入工作队列（workQueue）。

  3. 当队列已满且当前线程数还没达到 maximumPoolSize

    • 继续创建新线程（但不超过 max）。

  4. 若队列已满并且已达 maximumPoolSize

    • 执行拒绝策略（默认 AbortPolicy 会抛异常）。

*简而言之：*先用“核心线程”，再排队；排队满了就扩大线程数到最大值；再无法受理就拒绝。

3. 关键参数与配置

ThreadPoolExecutor 的常见构造方法（简化）：

public ThreadPoolExecutor(
        int corePoolSize,
        int maximumPoolSize,
        long keepAliveTime,
        TimeUnit unit,
        BlockingQueue<Runnable> workQueue,
        ThreadFactory threadFactory,
        RejectedExecutionHandler handler) {
    ...
}

下表概括各参数作用和调优思路：

参数

意义

典型调优策略

corePoolSize

核心线程数，除非允许超时空闲，否则即便空闲也会保留这些线程

- 通常与系统可用 CPU 核数、任务性质（CPU密集/IO密集）相关。<br/>- 避免设置过大导致线程切换。

maximumPoolSize

最大线程数，当工作队列塞满后可继续创建线程，直到达到这个上限

- 不宜过高，否则易引发严重上下文切换或 OOM。<br/>- 建议在合理评估负载后设置。

keepAliveTime

线程空闲时，超过此时间就会被终止（非核心线程默认会被回收；若开启核心线程超时，也回收空闲核心线程）

- 对波动较大的任务量可适当调高，以避免频繁创建/销毁线程。

workQueue

存放待执行任务的队列，通常使用 LinkedBlockingQueue、SynchronousQueue 或 ArrayBlockingQueue 等

- 选择无界/有界队列取决于任务规模与内存限制。<br/>- 大小过大可能拖累响应时间；太小会频繁触发扩容或拒绝策略。

threadFactory

线程工厂，用于创建工作线程，可自定义线程名字、是否后台线程等

- 可自定义便于排查问题，比如给线程名加上业务标识。

handler (拒绝策略)

当任务无法受理时的处理方式，可选：<br/>• AbortPolicy（抛异常）<br/>• DiscardPolicy（丢任务）<br/>• DiscardOldestPolicy（丢最旧任务）<br/>• CallerRunsPolicy（在提交者线程执行）

- 结合业务需求选择合适策略。<br/>- 或自定义 handler，做降级/日志记录等操作。

4. 线程池监控与优化

4.1 监控方法

  1. ThreadPoolExecutor 提供的监控API：

    • getPoolSize()：当前池中线程总数

    • getActiveCount()：正在执行任务的线程数

    • getQueue().size()：队列中的等待任务数

    • getCompletedTaskCount()：已完成任务总数

  2. JMX 监控：

    • 通过 java.lang:type=Threading 或使用自定义 MBean 来实时观察线程使用情况。

  3. 外部监控工具：

    • 如 VisualVM、JConsole、Prometheus + Grafana，对线程池指标进行采集和可视化。

4.2 常见优化要点

  1. 合理设置核心线程数

    • 根据CPU核数、任务的计算/IO比重来估算，避免过多线程相互抢占 CPU。

  2. 限制最大线程数

    • 避免在流量高峰时创建海量线程，造成系统不稳定或 OOM。

  3. 选取合适队列

    • 大小队列可做“削峰填谷”；但太大可能导致过长延迟，太小容易频繁拒绝任务。

  4. 使用拒绝策略做“保护”

    • 高并发场景下，建议使用 CallerRunsPolicy 或自定义方案，让提交者承担一部分工作或拒绝低优先级任务。

  5. 核心线程超时

    • 通过 allowCoreThreadTimeOut(true) 在空闲时也回收核心线程，适合波动非常大的场景，节省资源。

  6. 命名线程

    • 自定义 ThreadFactory：给线程池的线程起易识别的名字，方便排查问题。

5. 小结

  1. 工作流程： 先用核心线程处理任务 → 队列排队 → 超过队列则扩容至最大线程数 → 再不行就拒绝。

  2. 关键参数：

    • corePoolSize、maximumPoolSize 决定并发线程数量上下限；

    • workQueue 决定排队策略和长度；

    • 拒绝策略影响系统在饱和时如何应对。

  3. 监控与调优：

    • 动态监控线程池运行状态（线程数、队列长度等）；

    • 合理设置线程数、队列大小、拒绝策略，确保稳定性与吞吐量。

  4. 实战建议：

    • 优先使用框架内置线程池（如 Executors.newFixedThreadPool / newCachedThreadPool 等），根据业务需求做更细调；

    • 对于核心业务，需定制 ThreadPoolExecutor 并结合监控与限流/降级措施，避免在极端情况下导致系统崩溃。

通过以上要点的掌握，可有效使用 Java 线程池完成并发任务的高效调度和资源管理，实现“高并发，低延迟”的应用目标。

6. 高级线程池用法

CachedThreadPool

  • 默认 最大 Interger. MAX_VALUE 线程数的线程池

  • ExecutorService service = Executors.newCachedThreadPool()

FixedThreadPool

  • 定长线程池，最优数量：Runtime.getRuntime().availableProcessors()

  • 不会释放线程

  • ExecutorService service Executors.newFixedThreadPool(10);

SingleThreadPool

  • 同时只有一个线程运行，可以按照指定顺序(FIFO, LIFO, 优先级)执行

  • ExecutorService service = Executors.newSingleThreadExecutor();

ScheduleThreadPool

  • 定时执行线程池

  • ExecutorService service = Executors.newScheduledThreadPool(10);

WorkStealingPool

  • Fork/Join

        public static void main(String[] args) throws IOException {
        // 根据cpu是几核来开启几个线程
        ExecutorService service = Executors.newWorkStealingPool();
        // 查看当前计算机是几核
        System.out.println(Runtime.getRuntime().availableProcessors());
        service.execute(new R(1000));
        service.execute(new R(2000));
        service.execute(new R(3000));
        service.execute(new R(1000));
        service.execute(new R(2000));

        // WorkStealing是精灵线程(守护线程、后台线程)，主线程不阻塞，看不到输出。
        // 虚拟机不停止，守护线程不停止
        System.in.read();
    }

    static class R implements Runnable {
        int time;

        public R(int time) {
            this.time = time;
        }

        @Override
        public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(time);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(time + ":" + Thread.currentThread().getName());
        }
    }
1000:ForkJoinPool-1-worker-1
1000:ForkJoinPool-1-worker-4
2000:ForkJoinPool-1-worker-2
2000:ForkJoinPool-1-worker-5
3000:ForkJoinPool-1-worker-3
PreviousJava LockNext深入理解 Java 并发工具

Last updated

Was this helpful?