ThreadPoolExecutor详解

Java并发工具类：ThreadPoolExecutor详解

一、核心特性与定位

1.1 线程池核心实现

ThreadPoolExecutor是Java并发包（JUC）中实现线程池管理的核心类，通过复用线程资源降低线程创建/销毁开销，提供任务队列、拒绝策略等高级特性，适用于需要高效管理并发任务的场景。

类结构定位：

1.2 核心特性矩阵

特性	行为表现	适用场景
核心线程池	长期存活的线程集合	基础并发能力
任务队列	阻塞队列缓冲待执行任务	流量削峰
拒绝策略	队列满时的任务处理策略	高并发防护
动态参数调整	运行时修改线程池配置	弹性伸缩场景
生命周期管理	支持优雅关闭	系统平稳退出

二、核心机制解析

2.0. 类结构

public class ThreadPoolExecutor extends AbstractExecutorService {
    // 核心参数
    private volatile int corePoolSize;
    private volatile int maximumPoolSize;
    private volatile long keepAliveTime;
    private volatile BlockingQueue<Runnable> workQueue;
    private volatile ThreadFactory threadFactory;
    private volatile RejectedExecutionHandler handler;

    // 线程池状态与线程数（高3位存储状态，低29位存储线程数）
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    private static final int COUNT_BITS = Integer.SIZE - 3;
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // 状态常量
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   = 0 << COUNT_BITS;
    private static final int STOP       = 1 << COUNT_BITS;
    private static final int TIDYING    = 2 << COUNT_BITS;
    private static final int TERMINATED = 3 << COUNT_BITS;

    // 工作线程集合
    private final HashSet<Worker> workers = new HashSet<>();

    // 核心方法：执行任务
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        if (workerCountOf(c) < corePoolSize) { // 1. 创建核心线程
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        if (isRunning(c) && workQueue.offer(command)) { // 2. 任务入队
            int recheck = ctl.get();
            if (!isRunning(recheck) && remove(command)) // 3. 线程池关闭时拒绝任务
                reject(command);
            else if (workerCountOf(recheck) == 0) // 4. 空线程池时创建非核心线程
                addWorker(null, false);
        }
        else if (!addWorker(command, false)) // 5. 创建非核心线程失败，触发拒绝策略
            reject(command);
    }

    // 核心方法：添加工作线程
    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
                return false;
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c)) // CAS 增加线程数
                    break retry;
                c = ctl.get();
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask); // 创建 Worker 对象
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    int rs = runStateOf(ctl.get());
                    if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive())
                            throw new IllegalThreadStateException();
                        workers.add(w); // 添加到工作线程集合
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start(); // 启动线程
                    workerStarted = true;
                }
            }
        } finally {
            if (!workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

    // 内部类：工作线程
    private final class Worker extends AbstractQueuedSynchronizer implements Runnable {
        private final Thread thread;
        private Runnable firstTask;

        Worker(Runnable firstTask) {
            this.firstTask = firstTask;
            this.thread = threadFactory.newThread(this); // 通过线程工厂创建线程
        }

        public void run() {
            runWorker(this); // 执行任务
        }
    }

    // 核心方法：执行工作线程
    final void runWorker(Worker w) {
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock();
        boolean completedAbruptly = true;
        try {
            while (task != null || (task = getTask()) != null) { // 循环获取任务
                w.lock();
                if ((runStateAtLeast(ctl.get(), STOP) ||
                     (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) &&
                    !wt.isInterrupted())
                    wt.interrupt();
                try {
                    beforeExecute(wt, task); // 执行前钩子
                    Throwable thrown = null;
                    try {
                        task.run(); // 执行任务
                    } catch (RuntimeException x) {
                        thrown = x; throw x;
                    } catch (Error x) {
                        thrown = x; throw x;
                    } catch (Throwable x) {
                        thrown = x; throw new Error(x);
                    } finally {
                        afterExecute(task, thrown); // 执行后钩子
                    }
                } finally {
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly); // 处理线程退出
        }
    }

    // 核心方法：获取任务（可能阻塞）
    private Runnable getTask() {
        boolean timedOut = false;
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
            int wc = workerCountOf(c);
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
            if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
                if (compareAndDecrementWorkerCount(c))
                    return null;
                continue;
            }
            try {
                Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); // 从队列获取任务
                if (r != null)
                    return r;
                timedOut = true;
            } catch (InterruptedException retry) {
                timedOut = false;
            }
        }
    }

    // 核心方法：处理线程退出
    private void processWorkerExit(Worker w, boolean completedAbruptly) {
        if (completedAbruptly)
            decrementWorkerCount();
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w); // 从工作线程集合移除
        } finally {
            mainLock.unlock();
        }
        tryTerminate(); // 尝试终止线程池
    }
}

2.0.1. 关键方法详解

• execute(Runnable command)：

  • 提交任务到线程池，根据当前线程数和队列状态决定创建线程或拒绝任务。

• addWorker(Runnable firstTask, boolean core)：

  • 创建并启动工作线程（Worker 对象），核心线程或非核心线程由 core 参数控制。

• runWorker(Worker w)：

  • 工作线程的主循环，不断从任务队列获取任务并执行。

• getTask()：

  • 从任务队列获取任务，支持超时（非核心线程空闲超时）。

• processWorkerExit(Worker w, boolean completedAbruptly)：

  • 清理退出线程的资源，尝试终止线程池。

2.1 线程管理模型

线程工厂模式：

// 自定义线程工厂
public class CustomThreadFactory implements ThreadFactory {
    private final AtomicInteger count = new AtomicInteger(1);
    private final String namePrefix;

    public CustomThreadFactory(String poolName) {
        this.namePrefix = poolName + "-worker-";
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r, namePrefix + count.getAndIncrement());
        t.setUncaughtExceptionHandler((thread, ex) -> 
            log.error("Uncaught exception: {}", ex));
        return t;
    }
}

2.2 任务执行流程

2.3 拒绝策略实现

内置策略：

// AbortPolicy（默认）
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    throw new RejectedExecutionException("Task " + r.toString() +
                                         " rejected from " +
                                         e.toString());
}

// CallerRunsPolicy
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    if (!e.isShutdown()) {
        r.run();
    }
}

三、典型使用场景

3.1 异步任务处理

订单处理系统：

// 核心线程数=CPU核数，队列=SynchronousQueue
ExecutorService orderProcessor = new ThreadPoolExecutor(
    Runtime.getRuntime().availableProcessors(),
    Integer.MAX_VALUE,
    60L, TimeUnit.SECONDS,
    new SynchronousQueue<>(),
    new CustomThreadFactory("order-pool"));

// 提交订单处理任务
orderProcessor.execute(() -> processOrder(order));

3.2 定时任务调度

周期性数据同步：

// 创建定时任务线程池
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(4,
    new CustomThreadFactory("schedule-pool"));

// 提交周期性任务
scheduler.scheduleAtFixedRate(() -> {
    syncDataToRemote();
}, 0, 1, TimeUnit.HOURS);

3.3 资源隔离

多业务线隔离：

// 不同业务线使用独立线程池
Map<String, ExecutorService> poolRegistry = new ConcurrentHashMap<>();

public ExecutorService getBusinessPool(String business) {
    return poolRegistry.computeIfAbsent(business, k -> 
        new ThreadPoolExecutor(
            4, 16,
            60L, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1024),
            new CustomThreadFactory(business + "-pool")
        )
    );
}

四、最佳实践

4.1 参数配置原则

容量规划公式：

• 核心线程数：N_cpu = Runtime.getRuntime().availableProcessors()
• 最大线程数：N_cpu * U_cpu * (1 + W/C)
  • U_cpu：目标CPU利用率（0-1）
  • W/C：等待时间与计算时间的比值

队列选择策略：

场景	推荐队列类型
低延迟要求	SynchronousQueue
高吞吐量要求	LinkedBlockingQueue
优先级调度	PriorityBlockingQueue
有界资源控制	ArrayBlockingQueue

4.2 监控与调优

关键监控指标：

// 自定义监控实现
ThreadPoolExecutor pool = (ThreadPoolExecutor) executor;
Metrics.gauge("threadpool.active", pool::getActiveCount);
Metrics.gauge("threadpool.queue.size", pool::getQueue::size);
Metrics.gauge("threadpool.completed", pool::getCompletedTaskCount);

动态调优示例：

// 根据负载动态调整核心线程数
if (pool.getActiveCount() > pool.getCorePoolSize() * 0.8) {
    pool.setCorePoolSize(Math.min(pool.getCorePoolSize() + 4, 
                                 pool.getMaximumPoolSize()));
}

4.3 优雅关闭

三阶段关闭流程：

// 关闭流程
public void shutdownGracefully(ExecutorService pool) {
    // 1. 停止接收新任务
    pool.shutdown();
    
    // 2. 等待任务完成（带超时）
    try {
        if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
            // 3. 强制终止剩余任务
            pool.shutdownNow();
        }
    } catch (InterruptedException e) {
        pool.shutdownNow();
        Thread.currentThread().interrupt();
    }
}

五、常见问题与解决方案

5.1 线程泄漏问题

现象：

• 活跃线程数持续增加
• 任务队列堆积但线程数未达上限

解决方案：

// 线程工厂添加存活日志
public class DebugThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setUncaughtExceptionHandler((thread, ex) -> 
            log.error("Thread {} died: {}", thread.getName(), ex));
        log.debug("Created thread: {}", t.getName());
        return t;
    }
}

// 使用示例
ExecutorService pool = new ThreadPoolExecutor(4, 16, 60, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(1024), new DebugThreadFactory());

5.2 任务拒绝

典型场景：

• 突发流量超过队列容量
• 长时间阻塞任务填满队列

预防措施：

// 自定义预警拒绝策略
public class AlertingAbortPolicy implements RejectedExecutionHandler {
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        log.warn("Task {} rejected from {}", r, executor);
        Metrics.counter("task.rejected").inc();
        throw new RejectedExecutionException("Task rejected");
    }
}

5.3 性能瓶颈定位

诊断工具链：

1. JFR飞行记录：

   java -XX:StartFlightRecording=filename=threadpool.jfr,settings=profile -jar app.jar
   

2. Async Profiler：

   ./profiler.sh -d 60 -f flamegraph.html <pid>
   

3. 线程转储分析：

   # 查找阻塞线程
   jstack <pid> | grep -A 20 "BLOCKED"
   

六、高级特性应用

6.1 装饰器模式扩展

监控增强实现：

// 任务执行装饰器
public class MonitoringDecorator implements Runnable {
    private final Runnable delegate;
    private final long startTime;

    public MonitoringDecorator(Runnable delegate) {
        this.delegate = delegate;
        this.startTime = System.nanoTime();
    }

    @Override
    public void run() {
        try {
            delegate.run();
        } finally {
            long duration = System.nanoTime() - startTime;
            Metrics.histogram("task.duration", duration);
        }
    }
}

// 使用示例
ExecutorService pool = Executors.newFixedThreadPool(4);
pool = Executors.newSingleThreadExecutor(() -> 
    new MonitoringDecorator(pool.submit(() -> {})));

6.2 上下文传递

TransmittableThreadLocal集成：

// 使用TTL装饰线程池
ExecutorService ttlPool = TtlExecutors.getTtlExecutorService(pool);

// 提交携带上下文的任务
try (TtlContext context = TtlContext.newContext()) {
    context.put("traceId", UUID.randomUUID().toString());
    ttlPool.submit(() -> {
        String currentTrace = TtlContext.get().getString("traceId");
        log.info("Processing with traceId: {}", currentTrace);
    });
}

6.3 弹性伸缩

动态参数调整：

// 根据负载动态调整线程池参数
ScheduledExecutorService adjustor = Executors.newSingleThreadScheduledExecutor();
adjustor.scheduleAtFixedRate(() -> {
    int active = pool.getActiveCount();
    int queueSize = pool.getQueue().size();
    
    if (active > pool.getCorePoolSize() * 0.8 && 
        pool.getCorePoolSize() < pool.getMaximumPoolSize()) {
        pool.setCorePoolSize(pool.getCorePoolSize() + 1);
    }
    
    if (queueSize > 1000 && pool.getMaximumPoolSize() < 128) {
        pool.setMaximumPoolSize(pool.getMaximumPoolSize() + 16);
    }
}, 0, 5, TimeUnit.SECONDS);

七、源码关键逻辑

1. ctl 字段：

   • 使用位运算（高3位存储状态，低29位存储线程数）高效管理线程池状态和线程数。

2. Worker 对象：

   • 每个工作线程封装为 Worker 对象，继承自 AbstractQueuedSynchronizer 实现简单的锁机制。

3. 任务队列交互：

   • 通过 workQueue.offer() 和 workQueue.take() 实现任务缓冲和阻塞获取。

八、总结

ThreadPoolExecutor 通过灵活的参数配置和高效的任务调度机制，实现了线程池的核心功能。其源码核心在于：

• ctl 字段管理：位运算高效管理线程池状态和线程数。
• Worker 线程模型：通过 Worker 对象封装工作线程，实现任务循环执行。
• 任务队列交互：与 BlockingQueue 协作，实现任务缓冲和流量控制。

理解其源码有助于在并发编程中合理配置线程池，避免资源竞争和性能瓶颈。