本文围绕Java的ThreadPoolExecutor线程池展开，介绍了线程池解决的问题和好处，如降低资源消耗、提高可管理性等。结合源码分析了其UML类图、状态、运行机制，包括任务调度和Worker线程管理。还给出了线程池的应用场景、常见配置策略，并推荐了动态线程池框架。
-
大家好，我是 Lorin。随着计算机行业的飞速发展，摩尔定律逐渐失效，多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。J.U.C提供的线程池：ThreadPoolExecutor类，帮助开发人员管理线程并方便地执行并行任务。
-
本文从线程池概念和用途开始介绍，然后接着结合线程池的源码，领略线程池的设计思路，最后结合实践介绍线程使用的一些常见案例以及线程池参数配置难题引出动态线程池。无论您是一个经验丰富的Java开发者，还是刚刚起步的新手，我相信您都将从本文中获得有价值的信息和见解。
-
线程池是一种并发编程的工具，它管理和复用线程，以便更有效地执行多个任务。线程池维护一组可用线程，任务到达时将其分配给这些线程，执行完成后线程可以被重新用于执行其他任务。线程池的主要目标是减少线程的创建和销毁开销，提高系统的性能和稳定性。
线程池解决的问题和带来的好处
降低资源消耗，提高响应速度
-
通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。
-
任务到达时，无需等待线程创建即可立即执行，提高响应速度。
提高线程的可管理性，保证系统的稳定性
-
线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控。
提供更多更强大的功能
-
线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如定时线程池ScheduledThreadPoolExecutor，允许任务延期执行或定期执行。
-
线程池是一种通过“池化”思想，帮助我们管理线程而获取并发性的工具，在Java中的体现是ThreadPoolExecutor类。下面我们来看一下它的核心设计与具体实现。
-
源码JDK版本：1.8
ThreadPoolExecutor UML类图
-
ThreadPoolExecutor实现的顶层接口是Executor，顶层接口Executor提供了一种思想：将任务提交和任务执行进行解耦。用户无需关注如何创建线程，如何调度线程来执行任务，用户只需提供Runnable对象，将任务的运行逻辑提交到执行器(Executor)中，由Executor框架完成线程的调配和任务的执行部分。
-
ExecutorService接口增加了一些能力：（1）扩充执行任务的能力，补充可以为一个或一批异步任务生成Future的方法；（2）提供了管控线程池的方法，比如停止线程池的运行。
-
AbstractExecutorService则是上层的抽象类，将执行任务的流程串联了起来，保证下层的实现只需关注一个执行任务的方法即可。
-
最下层的实现类ThreadPoolExecutor实现最复杂的运行部分，ThreadPoolExecutor将会一方面维护自身的生命周期，另一方面同时管理线程和任务，使两者良好的结合从而执行并行任务。
ThreadPoolExecutor 状态
-
线程池的状态并不是由用户显示维护，而是伴随线程池运行由内部进行维护，线程池内部使用一个变量维护两个值：运行状态(runState)和线程数量 (workerCount)。
-
在具体实现中，线程池将运行状态(runState)、线程数量 (workerCount)两个关键参数的维护放在了一起（使用原子操作保证读取和修改线程安全，而不使用额外的锁），如下代码所示：
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;
运行状态
-
从上面我们可以知道，线程池共有 5 种状态：
| 运行状态 | 说明 |
|---|---|
| RUNNING | 能接受新任务提交，也能处理阻塞队列中的任务 |
| SHUTDOWN | 关闭状态，无法接受新任务，但可以处理阻塞队列中的任务 |
| STOP | 无法接受新任务且不会处理阻塞队列的任务，同时中断所有线程 |
| TIDYING | 所有任务已取消，线程数量 (workerCount) = 0 |
| TERMINATED | terminated() 执行完成后进入 TERMINATED 状态 |
运行状态转换
ThreadPoolExecutor 运行机制
-
我们先看一下 ThreadPoolExecutor 的整体运行机制，可以发现整体分为任务调度和 Worker 线程管理两大部分：
任务调度
-
从上面可以看出，当我们提交一个可运行任务时，我们会进行任务调度，任务调度逻辑如下：
1、当线程数小于核心线程数，创建新线程执行任务
2、当线程数大于等于核心线程数，尝试将任务放入阻塞队列
3、若放入阻塞队列失败
判断线程数是否小于最大线程数，若是，创建一个线程执行该任务，否则拒绝任务
4、若放入阻塞队列成功，结束
源码分析
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
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);
}
else if (!addWorker(command, false))
reject(command);
}
任务缓冲
-
线程池的本质是使用解耦的思想将任务和线程管理分开，从而使用生产者-消费者的模式来对任务进行调度分配。
-
线程池通过阻塞队列实现生产者-消费者，在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。
-
同时支持不同的阻塞队列来实现不同存取策略：
任务拒绝策略
-
任务拒绝模块是线程池的保护部分，线程池有一个最大的容量，当线程池的任务缓存队列已满，并且线程池中的线程数目达到maximumPoolSize时，就需要拒绝掉该任务，采取任务拒绝策略，保护线程池。
-
JUC 提供了四种拒绝策略，我们也可以实现 RejectedExecutionHandler 接口实现自己想要的拒绝策略：
* A handler for tasks that cannot be executed by a {@link ThreadPoolExecutor}.
*
* @since 1.5
* @author Doug Lea
*/
public interface RejectedExecutionHandler {
* Method that may be invoked by a {@link ThreadPoolExecutor} when
* {@link ThreadPoolExecutor#execute execute} cannot accept a
* task. This may occur when no more threads or queue slots are
* available because their bounds would be exceeded, or upon
* shutdown of the Executor.
*
* <p>In the absence of other alternatives, the method may throw
* an unchecked {@link RejectedExecutionException}, which will be
* propagated to the caller of {@code execute}.
*
* @param r the runnable task requested to be executed
* @param executor the executor attempting to execute this task
* @throws RejectedExecutionException if there is no remedy
*/
void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}
Worker 线程管理
-
Worker 线程管理是线程池的第二个核心部分，主要负责 Worker 创建、Worker 执行（获取任务、执行任务）、Worker 回收三部分主要功能。
-
先看一下 Worker 的结构：
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
* This class will never be serialized, but we provide a
* serialVersionUID to suppress a javac warning.
*/
private static final long serialVersionUID = 6138294804551838833L;
final Thread thread;
Runnable firstTask;
volatile long completedTasks;
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
public void run() {
runWorker(this);
}
添加 Worker
-
线程池任务调度和线程池自适应状态调整过程中会使用 addWorker() 方法尝试添加 Worker。
源码解析
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))
break retry;
c = ctl.get();
if (runStateOf(c) != rs)
continue retry;
retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
w = new Worker(firstTask);
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);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
* Rolls back the worker thread creation.
* - removes worker from workers, if present
* - decrements worker count
* - rechecks for termination, in case the existence of this
* worker was holding up termination
*/
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
Woker 执行（获取任务、执行任务）
-
通过自循环的方式不断获取阻塞队列的任务并执行任务。
-
当获取任务失败会进入 Woker 回收流程。
源码分析
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 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();
int c = ctl.get();
if (runStateLessThan(c, STOP)) {
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return;
}
addWorker(null, false);
}
}
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;
}
}
}
回收 Worker
-
上文我们提到 Worker 运行过程中若获取 Task 失败则会进入 Worker 回收流程。
-
Worker 的回收依赖 JVM 的垃圾回收，线程池根据当前线程池状态维护一定 Worker 的引用，当 Worker 获取不到任务时，则会触发 Worker 回收流程，实际上就是消除 Woker 的引用，等待 JVM 回收。
源码分析
try {
while (task != null || (task = getTask()) != null) {
}
} finally {
processWorkerExit(w, completedAbruptly);
}
-
线程池提供了两种关闭线程池的方法:
void shutdown();
List<Runnable> shutdownNow();
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(SHUTDOWN);
interruptIdleWorkers();
onShutdown();
} finally {
mainLock.unlock();
}
tryTerminate();
}
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
advanceRunState(STOP);
interruptWorkers();
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
* Transitions to TERMINATED state if either (SHUTDOWN and pool
* and queue empty) or (STOP and pool empty). If otherwise
* eligible to terminate but workerCount is nonzero, interrupts an
* idle worker to ensure that shutdown signals propagate. This
* method must be called following any action that might make
* termination possible -- reducing worker count or removing tasks
* from the queue during shutdown. The method is non-private to
* allow access from ScheduledThreadPoolExecutor.
*/
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) {
interruptIdleWorkers(ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
terminated();
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
}
}
快速响应用户请求
-
用户发起查询请求，追求快速响应，比如查询商品信息，需要查询商品价格、优惠、图片等。
-
如果使用串联查询，那么时间将会花费很长时间，我们可以使用线程池进行并发IO，这种场景对实时要求较高，因此一般设置更多的线程执行，避免任务阻塞延迟，极大的提高响应时间。
离线大数据量并行计算
-
在一些大数据量的离线计算中，比如需要计算全球商品每年的报表信息，这类任务对实时性要求不高，但计算量大，因此可以设置合适的线程数来处理任务，并设置合理的阻塞队列来缓存待执行的任务。
-
线程池使用中最大的一个难点是：“如何合理的配置线程池参数”，一方面依赖于任务本身的特性：如 IO 密集性任务或 CPU 密集型任务，另一方面依赖于开发者的使用经验。
常见配置策略
-
在高性能 MySQL 中看到内核线程推荐配置策略为：核心线程数设置为稳定时请求量值，最大线程设置为波动峰值来解决峰值问题，这是一个可以借鉴的策略，但需要考虑本身机器的性能和任务属性，否则反而会使性能下降。
动态线程池
-
尽管我们经过谨慎的探讨和计算，但最终配置的参数也不一定满足我们的要求，因此我们考虑通过动态配置的方式来动态调整我们的线程池参数。
-
而 ThreadPoolExecutor 正好提供运行时调整参数的能力：
动态线程池框架推荐
-
轻量级动态线程池，内置监控告警功能，集成三方中间件线程池管理，支持主流配置中心。
-
dynamic-tp
-
我们使用线程池的本质是为了并发处理任务，任务并发处理我们根据业务的实际情况也可以考虑以下几种可选方案：
-
随着 JDK21 虚拟线程（协程）的推出，使我们有了更多的选择，可以根据实际的应用场景选择合适并发处理方案。
扫一扫
5198
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
