java中的所说的线程池，一般都是围绕着 ThreadPoolExecutor 来展开的。其他的实现基本都是基于它，或者模仿它的。所以只要理解 ThreadPoolExecutor, 就相当于完全理解了线程池的精髓。
其实要理解一个东西，一般地，我们最好是要抱着自己的疑问或者理解去的。否则，往往收获甚微。
理解 ThreadPoolExecutor, 我们可以先理解一个线程池的意义: 本质上是提供预先定义好的n个线程，供调用方直接运行任务的一个工具。
线程池解决的问题:
1. 提高任务执行的响应速度，降低资源消耗。任务执行时，直接立即使用线程池提供的线程运行，避免了临时创建线程的CPU/内存开销，达到快速响应的效果。
2. 提高线程的可管理性。线程总数可预知，避免用户主动创建无限多线程导致死机风险，还可以进行线程统一的分配、调优和监控。
3. 避免对资源的过度使用。在超出预期的请求任务情况，响应策略可控。
线程池提供的核心接口:
要想使用线程池，自然是要理解其接口的。一般我们使用 ExecotorService 进行线程池的调用。然而，我们并不针对初学者。
整体的接口如下:
我们就挑几个常用接口探讨下：
submit(Runnable task): 提交一个无需返回结果的任务。
submit(Callable<T> task): 提交一个有返回结果的任务。
invokeAll(Collection<? extends Callable<T>> tasks, long, TimeUnit): 同时执行n个任务并返回结果列表。
shutdown(): 关闭线程程池。
awaitTermination(long timeout, TimeUnit unit): 等待关闭结果，最长不超过timeout时间。
以上是ThreadPoolExector 提供的特性，针对以上特性。
我们应该要有自己的几个实现思路或疑问:
1. 线程池如何接受任务？
2. 线程如何运行任务？
3. 线程池如何关闭？
接下来，就让我们带着疑问去看实现吧。
ThreadPoolExecutor 核心实现原理
1. 线程池的处理流程
我们首先重点要看的是，如何执行提交的任务。我可以通过下图来看看。
总结描述下就是:
1. 判断核心线程池是否已满，如果不是，则创建线程执行任务
2. 如果核心线程池满了，判断队列是否满了，如果队列没满，将任务放在队列中
3. 如果队列满了，则判断线程池是否已满，如果没满，创建线程执行任务
4. 如果线程池也满了，则按照拒绝策略对任务进行处理
另外，我们来看一下 ThreadPoolExecutor 的构造方法，因为这里会体现出每个属性的含义。
/**
* Creates a new {@code ThreadPoolExecutor} with the given initial
* parameters.
*
* @param corePoolSize the number of threads to keep in the pool, even
* if they are idle, unless {@code allowCoreThreadTimeOut} is set
* @param maximumPoolSize the maximum number of threads to allow in the
* pool
* @param keepAliveTime when the number of threads is greater than
* the core, this is the maximum time that excess idle threads
* will wait for new tasks before terminating.
* @param unit the time unit for the {@code keepAliveTime} argument
* @param workQueue the queue to use for holding tasks before they are
* executed. This queue will hold only the {@code Runnable}
* tasks submitted by the {@code execute} method.
* @param threadFactory the factory to use when the executor
* creates a new thread
* @param handler the handler to use when execution is blocked
* because the thread bounds and queue capacities are reached
* @throws IllegalArgumentException if one of the following holds:<br>
* {@code corePoolSize < 0}<br>
* {@code keepAliveTime < 0}<br>
* {@code maximumPoolSize <= 0}<br>
* {@code maximumPoolSize < corePoolSize}
* @throws NullPointerException if {@code workQueue}
* or {@code threadFactory} or {@code handler} is null
*/
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
从构造方法可以看出 ThreadPoolExecutor 的主要参数 7 个，在其注释上也有说明功能，咱们翻译下每个参数的功能:
corePoolSize: 线程池核心线程数（平时保留的线程数）,使用时机: 在初始时刻，每次请求进来都会创建一个线程直到达到该size
maximumPoolSize: 线程池最大线程数,使用时机: 当workQueue都放不下时，启动新线程，直到最大线程数，此时到达线程池的极限
keepAliveTime/unit: 超出corePoolSize数量的线程的保留时间,unit为时间单位
workQueue: 阻塞队列，当核心线程数达到或者超出后，会先尝试将任务放入该队列由各线程自行消费;
ArrayBlockingQueue: 构造函数一定要传大小
LinkedBlockingQueue: 构造函数不传大小会默认为65536（Integer.MAX_VALUE ），当大量请求任务时，容易造成 内存耗尽。
SynchronousQueue: 同步队列，一个没有存储空间的阻塞队列 ，将任务同步交付给工作线程。
PriorityBlockingQueue: 优先队列
threadFactory：线程工厂,用于线程需要创建时，调用其newThread()生产新线程使用
handler: 饱和策略，当队列已放不下任务，且创建的线程已达到 maximum 后，则不能再处理任务，直接将任务交给饱和策略
AbortPolicy: 直接抛弃（默认）
CallerRunsPolicy: 用调用者的线程执行任务
DiscardOldestPolicy: 抛弃队列中最久的任务
DiscardPolicy: 抛弃当前任务
2. submit 流程详解
当调用 submit 方法，就是向线程池中提交一个任务，处理流程如步骤1所示。但是我们需要更深入理解。
submit 方法是定义在 AbstractExecutorService 中，最终调用 ThreadPoolExecutor 的 execute 方法，即是模板方法模式的应用。
// java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable, T)
/**
* @throws RejectedExecutionException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
*/
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) throw new NullPointerException();
// 封装任务和返回结果为 RunnableFuture, 统一交由具体的子类执行
RunnableFuture<T> ftask = newTaskFor(task, result);
// execute 将会调用 ThreadPoolExecutor 的实现，是我们讨论的重要核心
execute(ftask);
return ftask;
}
// FutureTask 是个重要的线程池组件，它承载了具体的任务执行流
/**
* Returns a {@code RunnableFuture} for the given runnable and default
* value.
*
* @param runnable the runnable task being wrapped
* @param value the default value for the returned future
* @param <T> the type of the given value
* @return a {@code RunnableFuture} which, when run, will run the
* underlying runnable and which, as a {@code Future}, will yield
* the given value as its result and provide for cancellation of
* the underlying task
* @since 1.6
*/
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
// ThreadPoolExecutor 的任务提交过程
// java.util.concurrent.ThreadPoolExecutor#execute
/**
* Executes the given task sometime in the future. The task
* may execute in a new thread or in an existing pooled thread.
*
* If the task cannot be submitted for execution, either because this
* executor has been shutdown or because its capacity has been reached,
* the task is handled by the current {@code RejectedExecutionHandler}.
*
* @param command the task to execute
* @throws RejectedExecutionException at discretion of
* {@code RejectedExecutionHandler}, if the task
* cannot be accepted for execution
* @throws NullPointerException if {@code command} is null
*/
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.
*/
// ctl 是一个重要的控制全局状态的数据结构，定义为一个线程安全的 AtomicInteger
// ctl = new AtomicInteger(ctlOf(RUNNING, 0));
int c = ctl.get();
// 当还没有达到核心线程池的数量时，直接添加1个新线程，然后让其执行任务即可
if (workerCountOf(c) < corePoolSize) {
// 2.1. 添加新线程，且执行command任务
// 添加成功，即不需要后续操作了，添加失败，则说明外部环境变化了
if (addWorker(command, true))
return;
c = ctl.get();
}
// 当核心线程达到后，则尝试添加到阻塞队列中，具体添加方法由阻塞队列实现
// isRunning => c < SHUTDOWN;
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
// 2.2. 添加队列成功后，还要再次检测线程池的运行状态，决定启动线程或者状态过期
// 2.2.1. 当线程池已关闭，则将刚刚添加的任务移除，走reject策略
if (! isRunning(recheck) && remove(command))
reject(command);
// 2.2.2. 当一个worker都没有时，则添加worker
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 当队列满后，则直接再创建新的线程运行，如果不能再创建线程了，则 reject
else if (!addWorker(command, false))
// 2.3. 拒绝策略处理
reject(command);
}
通过上面这一小段代码，我们就已经完整地看到了。通过一个 ctl 变量进行全局状态控制，从而保证了线程安全性。整个框架并没有使用锁，但是却是线程安全的。
整段代码刚好完整描述了线程池的执行流程:
1. 判断核心线程池是否已满，如果不是，则创建线程执行任务;
2. 如果核心线程池满了，判断队列是否满了，如果队列没满，将任务放在队列中;
3. 如果队列满了，则判断线程池是否已满，如果没满，创建线程执行任务;
4. 如果线程池也满了，则按照拒绝策略对任务进行处理;
2.1. 添加新的worker
一个worker，即是一个工作线程。
/**
* Checks if a new worker can be added with respect to current
* pool state and the given bound (either core or maximum). If so,
* the worker count is adjusted accordingly, and, if possible, a
* new worker is created and started, running firstTask as its
* first task. This method returns false if the pool is stopped or
* eligible to shut down. It also returns false if the thread
* factory fails to create a thread when asked. If the thread
* creation fails, either due to the thread factory returning
* null, or due to an exception (typically OutOfMemoryError in
* Thread.start()), we roll back cleanly.
*
* @param firstTask the task the new thread should run first (or
* null if none). Workers are created with an initial first task
* (in method execute()) to bypass queuing when there are fewer
* than corePoolSize threads (in which case we always start one),
* or when the queue is full (in which case we must bypass queue).
* Initially idle threads are usually created via
* prestartCoreThread or to replace other dying workers.
*
* @param core if true use corePoolSize as bound, else
* maximumPoolSize. (A boolean indicator is used here rather than a
* value to ensure reads of fresh values after checking other pool
* state).
* @return true if successful
*/
private boolean addWorker(Runnable firstTask, boolean core) {
// 为确保线程安全，进行CAS反复重试
retry:
for (;;) {
int c = ctl.get();
// 获取runState , c 的高位存储
// c & ~CAPACITY;
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 已经shutdown, firstTask 为空的添加并不会成功
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;
// CAS 更新worker+1数，成功则说明占位成功退出retry，后续的添加操作将是安全的，失败则说明已有其他线程变更该值
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
// runState 变更，则退出到 retry 重新循环
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
// 以下为添加 worker 过程
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 使用 Worker 封闭 firstTask 任务，后续运行将由 Worker 接管
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
// 添加 worker 的过程，需要保证线程安全
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
// SHUTDOWN 情况下还是会创建 Worker, 但是后续检测将会失败
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// 既然是新添加的线程，就不应该是 alive 状态
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// workers 只是一个工作线程的容器，使用 HashSet 承载
// private final HashSet<Worker> workers = new HashSet<Worker>();
workers.add(w);
int s = workers.size();
// 维护一个全局达到过的最大线程数计数器
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// worker 添加成功后，进行将worker启起来，里面应该是有一个 死循环，一直在获取任务
// 不然怎么运行添加到队列里的任务呢？
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
// 如果任务启动失败，则必须进行清理，返回失败
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
// 大概添加 worker 的框架明白了，重点对象是 Worker, 我们稍后再讲
// 现在先来看看，添加失败的情况，如何进行
/**
* 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);
// ctl 中的 workerCount - 1 , CAS 实现
decrementWorkerCount();
// 尝试处理空闲线程
tryTerminate();
} finally {
mainLock.unlock();
}
}
/**
* Decrements the workerCount field of ctl. This is called only on
* abrupt termination of a thread (see processWorkerExit). Other
* decrements are performed within getTask.
*/
private void decrementWorkerCount() {
do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}
// 停止可能启动的 worker
/**
* 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();
// 线程池正在运行、正在清理、已关闭但队列还未处理完，都不会进行 terminate 操作
if (isRunning(c) ||
// c >= TIDYING
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
// 停止线程的两个方式之一，只中断一个 worker
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 为唤醒等待关闭的线程
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
/**
* Interrupts threads that might be waiting for tasks (as
* indicated by not being locked) so they can check for
* termination or configuration changes. Ignores
* SecurityExceptions (in which case some threads may remain
* uninterrupted).
*
* @param onlyOne If true, interrupt at most one worker. This is
* called only from tryTerminate when termination is otherwise
* enabled but there are still other workers. In this case, at
* most one waiting worker is interrupted to propagate shutdown
* signals in case all threads are currently waiting.
* Interrupting any arbitrary thread ensures that newly arriving
* workers since shutdown began will also eventually exit.
* To guarantee eventual termination, it suffices to always
* interrupt only one idle worker, but shutdown() interrupts all
* idle workers so that redundant workers exit promptly, not
* waiting for a straggler task to finish.
*/
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 迭代所有 worker
for (Worker w : workers) {
Thread t = w.thread;
// 获取到 worker 的锁之后，再进行 interrupt
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (SecurityException ignore) {
} finally {
w.unlock();
}
}
// 只中断一个 worker, 立即返回, 不保证 interrupt 成功
if (onlyOne)
break;
}
} finally {
mainLock.unlock();
}
}
2.2. 当添加队列成功后，发现线程池状态变更，需要进行移除队列操作
/**
* Removes this task from the executor‘s internal queue if it is
* present, thus causing it not to be run if it has not already
* started.
*
* <p>This method may be useful as one part of a cancellation
* scheme. It may fail to remove tasks that have been converted
* into other forms before being placed on the internal queue. For
* example, a task entered using {@code submit} might be
* converted into a form that maintains {@code Future} status.
* However, in such cases, method {@link #purge} may be used to
* remove those Futures that have been cancelled.
*
* @param task the task to remove
* @return {@code true} if the task was removed
*/
public boolean remove(Runnable task) {
// 此移除不一定能成功
boolean removed = workQueue.remove(task);
// 上面已经看过，它会尝试停止一个 worker 线程
tryTerminate(); // In case SHUTDOWN and now empty
return removed;
}
3. 添加失败进行执行拒绝策略
/**
* Invokes the rejected execution handler for the given command.
* Package-protected for use by ScheduledThreadPoolExecutor.
*/
final void reject(Runnable command) {
// 拒绝策略是在构造方法时传入的，默认为 RejectedExecutionHandler
// 即用户只需实现 rejectedExecution 方法，即可以自定义拒绝策略了
handler.rejectedExecution(command, this);
}
4. Worker 的工作机制
从上面的实现中，我们可以看到，主要是对 Worker 的添加和 workQueue 的添加，所以具体的工作是由谁完成呢？自然就是 Worker 了。
// Worker 的构造方法，主要是接受一个 task, 可以为 null, 如果非null, 将在不久的将来被执行
// private final class Worker extends AbstractQueuedSynchronizer implements Runnable
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// 将 Worker 自身当作一个 任务，绑定到 worker.thread 中
// thread 启动时，worker 就启动了
this.thread = getThreadFactory().newThread(this);
}
// Worker 的主要工作实现，通过一个循环扫描实现
/** Delegates main run loop to outer runWorker */
public void run() {
// 调用 ThreadPoolExecutor 外部实现的 runWorker 方法
runWorker(this);
}
/**
* Main worker run loop. Repeatedly gets tasks from queue and
* executes them, while coping with a number of issues:
*
* 1. We may start out with an initial task, in which case we
* don‘t need to get the first one. Otherwise, as long as pool is
* running, we get tasks from getTask. If it returns null then the
* worker exits due to changed pool state or configuration
* parameters. Other exits result from exception throws in
* external code, in which case completedAbruptly holds, which
* usually leads processWorkerExit to replace this thread.
*
* 2. Before running any task, the lock is acquired to prevent
* other pool interrupts while the task is executing, and then we
* ensure that unless pool is stopping, this thread does not have
* its interrupt set.
*
* 3. Each task run is preceded by a call to beforeExecute, which
* might throw an exception, in which case we cause thread to die
* (breaking loop with completedAbruptly true) without processing
* the task.
*
* 4. Assuming beforeExecute completes normally, we run the task,
* gathering any of its thrown exceptions to send to afterExecute.
* We separately handle RuntimeException, Error (both of which the
* specs guarantee that we trap) and arbitrary Throwables.
* Because we cannot rethrow Throwables within Runnable.run, we
* wrap them within Errors on the way out (to the thread‘s
* UncaughtExceptionHandler). Any thrown exception also
* conservatively causes thread to die.
*
* 5. After task.run completes, we call afterExecute, which may
* also throw an exception, which will also cause thread to
* die. According to JLS Sec 14.20, this exception is the one that
* will be in effect even if task.run throws.
*
* The net effect of the exception mechanics is that afterExecute
* and the thread‘s UncaughtExceptionHandler have as accurate
* information as we can provide about any problems encountered by
* user code.
*
* @param w the worker
*/
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 不停地从 workQueue 中获取任务，然后执行，就是这么个逻辑
// getTask() 会阻塞式获取，所以 Worker 往往不会立即退出
while (task != null || (task = getTask()) != null) {
// 执行过程中是不允许并发的，即同时只能一个 task 在运行，此时也不允许进行 interrupt
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
// 检测是否已被线程池是否停止 或者当前 worker 被中断
// STOP = 1 << COUNT_BITS;
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
// 中断信息传递
wt.interrupt();
try {
// 任务开始前 切点，默认为空执行
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 直接调用任务的run方法， 具体的返回结果，会被 FutureTask 封装到 某个变量中
// 可以参考以前的文章 （FutureTask是怎样获取到异步执行结果的？ https://www.cnblogs.com/yougewe/p/11666284.html）
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();
}
}
// 正常退出，有必要的话，可能重新将 Worker 添加进来
completedAbruptly = false;
} finally {
// 处理退出后下一步操作，可能重新添加 Worker
processWorkerExit(w, completedAbruptly);
}
}
/**
* Performs cleanup and bookkeeping for a dying worker. Called
* only from worker threads. Unless completedAbruptly is set,
* assumes that workerCount has already been adjusted to account
* for exit. This method removes thread from worker set, and
* possibly terminates the pool or replaces the worker if either
* it exited due to user task exception or if fewer than
* corePoolSize workers are running or queue is non-empty but
* there are no workers.
*
* @param w the worker
* @param completedAbruptly if the worker died due to user exception
*/
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // If abrupt, then workerCount wasn‘t adjusted
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)) {
// 在 Worker 正常退出的情况下，检查是否超时导致，维持最小线程数
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
// 如果满足最小线程要求，则直接返回
if (workerCountOf(c) >= min)
return; // replacement not needed
}
// 否则再添加一个Worker到线程池中备用
// 非正常退出，会直接再添加一个Worker
addWorker(null, false);
}
}
/**
* Performs blocking or timed wait for a task, depending on
* current configuration settings, or returns null if this worker
* must exit because of any of:
* 1. There are more than maximumPoolSize workers (due to
* a call to setMaximumPoolSize).
* 2. The pool is stopped.
* 3. The pool is shutdown and the queue is empty.
* 4. This worker timed out waiting for a task, and timed-out
* workers are subject to termination (that is,
* {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
* both before and after the timed wait, and if the queue is
* non-empty, this worker is not the last thread in the pool.
*
* @return task, or null if the worker must exit, in which case
* workerCount is decremented
*/
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
// 如果进行了 shutdown, 且队列为空, 则需要将 worker 退出
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// do {} while (! compareAndDecrementWorkerCount(ctl.get()));
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// 线程数据大于最大允许线程，需要删除多余的 Worker
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
// 如果开户了超时删除功能，则使用 poll, 否则使用 take() 进行阻塞获取
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
// 获取到任务，则可以进行执行了
if (r != null)
return r;
// 如果有超时设置，则会在下一循环时退出
timedOut = true;
}
// 忽略中断异常
// 在这种情况下，Worker如何响应外部的中断请求呢？？？ 思考
catch (InterruptedException retry) {
timedOut = false;
}
}
}
所以，Worker的作用就体现出来了,一个循环取任务执行任务过程：
1. 有一个主循环一直进行任务的获取;
2. 针对有超时的设置，会使用poll进行获取任务，如果超时，则 Worker 将会退出循环结束线程;
3. 无超时的设置，则会使用 take 进行阻塞式获取，直到有值;
4. 获取任务执行前置+业务+后置任务;
5. 当获取到null的任务之后，当前Worker将会结束；
6. 当前Worker结束后，将会判断是否有必要维护最低Worker数，从而决定是否再添加Worker进来。
还是借用一个网上同学比较通用的一个图来表述下 Worker/ThreadPoolExecutor 的工作流程吧（已经很完美，不需要再造这轮子了）
5. shutdown 操作实现
ThreadPoolExecutor 是通过 ctl 这个变量进行全局状态维护的，shutdown 在线程池中也是表现为一个状态，所以应该是比较简单的。
/**
* Initiates an orderly shutdown in which previously submitted
* tasks are executed, but no new tasks will be accepted.
* Invocation has no additional effect if already shut down.
*
* <p>This method does not wait for previously submitted tasks to
* complete execution. Use {@link #awaitTermination awaitTermination}
* to do that.
*
* @throws SecurityException {@inheritDoc}
*/
public void shutdown() {
// 为保证线程安全，使用 mainLock
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// SecurityManager 检查
checkShutdownAccess();
// 设置状态为 SHUTDOWN
advanceRunState(SHUTDOWN);
// 中断空闲的 Worker, 即相当于依次关闭每个空闲线程
interruptIdleWorkers();
// 关闭钩子，默认实现为空操作，为方便子类实现自定义清理功能
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 再
tryTerminate();
}
/**
* Transitions runState to given target, or leaves it alone if
* already at least the given target.
*
* @param targetState the desired state, either SHUTDOWN or STOP
* (but not TIDYING or TERMINATED -- use tryTerminate for that)
*/
private void advanceRunState(int targetState) {
for (;;) {
int c = ctl.get();
// 自身CAS更新成功或者被其他线程更新成功
if (runStateAtLeast(c, targetState) ||
ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
break;
}
}
// 关闭空闲线程（非 running 状态）
/**
* Common form of interruptIdleWorkers, to avoid having to
* remember what the boolean argument means.
*/
private void interruptIdleWorkers() {
// 上文已介绍， 此处 ONLY_ONE 为 false, 即是最大可能地中断所有 Worker
interruptIdleWorkers(false);
}
与 shutdown 对应的，有一个 shutdownNow, 其语义是 立即停止所有任务。
/**
* Attempts to stop all actively executing tasks, halts the
* processing of waiting tasks, and returns a list of the tasks
* that were awaiting execution. These tasks are drained (removed)
* from the task queue upon return from this method.
*
* <p>This method does not wait for actively executing tasks to
* terminate. Use {@link #awaitTermination awaitTermination} to
* do that.
*
* <p>There are no guarantees beyond best-effort attempts to stop
* processing actively executing tasks. This implementation
* cancels tasks via {@link Thread#interrupt}, so any task that
* fails to respond to interrupts may never terminate.
*
* @throws SecurityException {@inheritDoc}
*/
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
checkShutdownAccess();
// 与 shutdown 的差别，设置的状态不一样
advanceRunState(STOP);
// 强行中断线程
interruptWorkers();
// 将未完成的任务返回
tasks = drainQueue();
} finally {
mainLock.unlock();
}
tryTerminate();
return tasks;
}
/**
* Interrupts all threads, even if active. Ignores SecurityExceptions
* (in which case some threads may remain uninterrupted).
*/
private void interruptWorkers() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (Worker w : workers)
// 调用 worker 的提供的中断方法
w.interruptIfStarted();
} finally {
mainLock.unlock();
}
}
// ThreadPoolExecutor.Worker#interruptIfStarted
void interruptIfStarted() {
Thread t;
if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
try {
// 直接调用任务的 interrupt
t.interrupt();
} catch (SecurityException ignore) {
}
}
}
6. invokeAll 的实现方式
invokeAll, 望文生义，即是调用所有给定的任务。想来应该是一个个地添加任务到线程池队列吧。
// invokeAll 的方法直接在抽象方便中就实现了，它的语义是同时执行n个任务，并同步等待结果返回
// java.util.concurrent.AbstractExecutorService#invokeAll(java.util.Collection<? extends java.util.concurrent.Callable<T>>)
public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException {
if (tasks == null)
throw new NullPointerException();
ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
boolean done = false;
try {
for (Callable<T> t : tasks) {
RunnableFuture<T> f = newTaskFor(t);
futures.add(f);
// 依次调用各子类的实现，添加任务
execute(f);
}
for (int i = 0, size = futures.size(); i < size; i++) {
Future<T> f = futures.get(i);
if (!f.isDone()) {
try {
// 依次等待执行结果
f.get();
} catch (CancellationException ignore) {
} catch (ExecutionException ignore) {
}
}
}
done = true;
return futures;
} finally {
if (!done)
for (int i = 0, size = futures.size(); i < size; i++)
futures.get(i).cancel(true);
}
}
实现很简单，都是些外围调用。
7. ThreadPoolExecutor 的状态值的设计
通过上面的过程，可以看到，整个ThreadPoolExecutor 非状态的依赖是非常强的。所以一个好的状态值的设计就显得很重要了，runState 代表线程池或者 Worker 的运行状态。如下：
// runState is stored in the high-order bits
// 整个状态使值使用 ctl 的高三位值进行控制， COUNT_BITS=29
// 1110 0000 0000 0000
private static final int RUNNING = -1 << COUNT_BITS;
// 0000 0000 0000 0000
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 0010 0000 0000 0000
private static final int STOP = 1 << COUNT_BITS;
// 0100 0000 0000 0000
private static final int TIDYING = 2 << COUNT_BITS;
// 0110 0000 0000 0000
private static final int TERMINATED = 3 << COUNT_BITS;
// 整个状态值的大小顺序主: RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
// 而低 29位，则用来保存 worker 的数量，当worker增加时，只要将整个 ctl 增加即可。
// 0001 1111 1111 1111, 即是最大的 worker 数量
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// 整个 ctl 描述为一个 AtomicInteger, 功能如下:
/**
* The main pool control state, ctl, is an atomic integer packing
* two conceptual fields
* workerCount, indicating the effective number of threads
* runState, indicating whether running, shutting down etc
*
* In order to pack them into one int, we limit workerCount to
* (2^29)-1 (about 500 million) threads rather than (2^31)-1 (2
* billion) otherwise representable. If this is ever an issue in
* the future, the variable can be changed to be an AtomicLong,
* and the shift/mask constants below adjusted. But until the need
* arises, this code is a bit faster and simpler using an int.
*
* The workerCount is the number of workers that have been
* permitted to start and not permitted to stop. The value may be
* transiently different from the actual number of live threads,
* for example when a ThreadFactory fails to create a thread when
* asked, and when exiting threads are still performing
* bookkeeping before terminating. The user-visible pool size is
* reported as the current size of the workers set.
*
* The runState provides the main lifecycle control, taking on values:
*
* RUNNING: Accept new tasks and process queued tasks
* SHUTDOWN: Don‘t accept new tasks, but process queued tasks
* STOP: Don‘t accept new tasks, don‘t process queued tasks,
* and interrupt in-progress tasks
* TIDYING: All tasks have terminated, workerCount is zero,
* the thread transitioning to state TIDYING
* will run the terminated() hook method
* TERMINATED: terminated() has completed
*
* The numerical order among these values matters, to allow
* ordered comparisons. The runState monotonically increases over
* time, but need not hit each state. The transitions are:
*
* RUNNING -> SHUTDOWN
* On invocation of shutdown(), perhaps implicitly in finalize()
* (RUNNING or SHUTDOWN) -> STOP
* On invocation of shutdownNow()
* SHUTDOWN -> TIDYING
* When both queue and pool are empty
* STOP -> TIDYING
* When pool is empty
* TIDYING -> TERMINATED
* When the terminated() hook method has completed
*
* Threads waiting in awaitTermination() will return when the
* state reaches TERMINATED.
*
* Detecting the transition from SHUTDOWN to TIDYING is less
* straightforward than you‘d like because the queue may become
* empty after non-empty and vice versa during SHUTDOWN state, but
* we can only terminate if, after seeing that it is empty, we see
* that workerCount is 0 (which sometimes entails a recheck -- see
* below).
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
8. awaitTermination 等待关闭完成
从上面的 shutdown, 可以看到，只是写了 SHUTDOWN 标识后，尝试尽可能地中断停止Worker线程，但并不保证中断成功。要想保证停止完成，需要有另外的机制来保证。从 awaitTermination 的语义来说，它是能保证任务停止完成的，那么它是如何保证的呢？
// ThreadPoolExecutor.awaitTermination()
public boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException {
long nanos = unit.toNanos(timeout);
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
for (;;) {
// 只是循环 ctl 状态, 只要 状态为 TERMINATED 状态，则说明已经关闭成功
// 此处 termination 的状态触发是在 tryTerminate 中触发的
if (runStateAtLeast(ctl.get(), TERMINATED))
return true;
if (nanos <= 0)
return false;
nanos = termination.awaitNanos(nanos);
}
} finally {
mainLock.unlock();
}
}
看起来, awaitTermination 并没有什么特殊操作，而是一直在等待。所以 TERMINATED 是 Worker 自行发生的动作。
那是在哪里做的操作呢？其实是在获取任务的时候，会检测当前状态是否是 SHUTDOWN, 如果是SHUTDOWN且 队列为空，则会触发获取任务的返回null.从而结束当前 Worker.
Worker 在结束前会调用 processWorkerExit() 方法，里面会再次调用 tryTerminate(), 当所有 Worker 都运行到这个点后， awaitTermination() 就会收到通知了。（注意: processWorkerExit() 会在每次运行后进行 addWorker() 尝试，但是在 SHUTDOWN 状态的添加操作总是失败的，所以不用考虑）
到此，你是否可以解答前面的几个问题了呢？
原文地址：https://www.cnblogs.com/yougewe/p/12267274.html
时间： 2024-10-04 19:50:10