ThreadPoolExecutor
线程池核心实现类线程池的生命周期
RUNNING: 接受新任务，同时处理工作队列中的任务
SHUTDOWN: 不接受新任务，但是能处理工作队列中的任务
STOP: 不接受新任务，不处理工作队列中的任务，并且强制中断正在运行的工作者线程。
TIDYING: 所有的工作者线程都已经停止，将运行 terminated() 钩子函数。
TERMINATED: terminated() 钩子函数运行完毕创建实例
/**
* 低 29 位设置为线程池的工作线程数
* 高 3 为设置为线程池的生命周期状态
*/
private final AtomicInteger ctl = new AtomicInteger(ThreadPoolExecutor.ctlOf(ThreadPoolExecutor.RUNNING, 0));
// 线程池的工作线程数在 int 中占用的位数
private static final int COUNT_BITS = Integer.SIZE - 3;
// 工作线程数掩码
private static final int COUNT_MASK = (1 << ThreadPoolExecutor.COUNT_BITS) - 1;
// runState is stored in the high-order bits
// 线程池处于运行状态：接受新任务，同时处理工作队列中的任务
private static final int RUNNING = -1 << ThreadPoolExecutor.COUNT_BITS;
// 线程池正在停止：不接受新任务，但是能处理工作队列中的任务
private static final int SHUTDOWN = 0 << ThreadPoolExecutor.COUNT_BITS;
// 线程池已经停止：不接受新任务，不处理工作队列中的任务，并且强制中断正在运行的工作者线程
private static final int STOP = 1 << ThreadPoolExecutor.COUNT_BITS;
// 线程池正在执行清理：所有的工作者线程都已经停止，将运行 terminated() 钩子函数
private static final int TIDYING = 2 << ThreadPoolExecutor.COUNT_BITS;
// 线程池已经清理完毕：terminated() 钩子函数运行完毕
private static final int TERMINATED = 3 << ThreadPoolExecutor.COUNT_BITS;
/**
* 任务队列，
* 1）如果工作者线程允许过期，则使用 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 读取任务
* 2）否则使用 workQueue.take() 读取任务
*/
private final BlockingQueue<Runnable> workQueue;
/**
* 添加工作者线程、关闭线程池、读取统计数据等操作中使用的互斥锁
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 线程池中的工作者线程集合，只有在持有 mainLock 时才能访问
*/
private final HashSet<Worker> workers = new HashSet<>();
/**
* 执行 awaitTermination 操作时的条件
*/
private final Condition termination = mainLock.newCondition();
/**
* 跟踪线程池同时存在的最大工作线程数
* Accessed only under mainLock.
*/
private int largestPoolSize;
/**
* 线程池完成的任务数，只在工作者线程退出时更新
* Accessed only under mainLock.
*/
private long completedTaskCount;
/**
* 任务队列，
* 1）如果工作者线程允许过期，则使用 workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) 读取任务
* 2）否则使用 workQueue.take() 读取任务
*/
private final BlockingQueue<Runnable> workQueue;
/**
* 添加工作者线程、关闭线程池、读取统计数据等操作中使用的互斥锁
*/
private final ReentrantLock mainLock = new ReentrantLock();
/**
* 线程池中的工作者线程集合，只有在持有 mainLock 时才能访问
*/
private final HashSet<Worker> workers = new HashSet<>();
/**
* 执行 awaitTermination 操作时的条件
*/
private final Condition termination = mainLock.newCondition();
/**
* 跟踪线程池同时存在的最大工作线程数
* Accessed only under mainLock.
*/
private int largestPoolSize;
/**
* 线程池完成的任务数，只在工作者线程退出时更新
* Accessed only under mainLock.
*/
private long completedTaskCount;
/**
* 创建工作者线程的工厂，工作者线程创建失败会导致任务丢失
*/
private volatile ThreadFactory threadFactory;
/**
* 线程池满载或关闭过程中，任务被拒绝时的处理器
*/
private volatile RejectedExecutionHandler handler;
/**
* 空闲工作者线程的超时时间，以纳秒为单位。
* 1）当前工作者线程数 > 核心线程数
* 2）允许核心工作者线程超时 allowCoreThreadTimeOut=true
*/
private volatile long keepAliveTime;
/**
* 默认为 false，即使超时了，核心工作者线程也不会退出
*/
private volatile boolean allowCoreThreadTimeOut;
/**
* 核心工作者线程数
*/
private volatile int corePoolSize;
/**
* 最大工作者线程数
*/
private volatile int maximumPoolSize;
/**
* 默认的拒绝处理器
*/
private static final RejectedExecutionHandler defaultHandler =
new AbortPolicy();
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), ThreadPoolExecutor.defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, ThreadPoolExecutor.defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
/**
* 使用指定的初始化参数创建一个 ThreadPoolExecutor 实例
*
* @param corePoolSize 核心工作者线程所
* @param maximumPoolSize 最大工作者线程数
* @param keepAliveTime 工作者线程存活时间
* @param unit 时间单位
* @param workQueue 工作队列
* @param threadFactory 创建工作者线程的线程工厂
* @param handler 拒绝处理器
*/
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
/**
* 必须保证
* corePoolSize >=0
* maximumPoolSize > 0
* maximumPoolSize > corePoolSize
* keepAliveTime > 0 表示工作者线程可超时退出
* keepAliveTime = 0 表示不可退出
*/
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0) {
throw new IllegalArgumentException();
}
if (workQueue == null || threadFactory == null || handler == null) {
throw new NullPointerException();
}
acc = System.getSecurityManager() == null
? null
: AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}可提交的任务类型
Runnable 接口无返回值并且不能显示抛出异常。
Callable 接口有返回值，并且能显示抛出异常。
@FunctionalInterface
public interface Runnable {
void run();
}
@FunctionalInterface
public interface Callable<V> {
/**
* 计算并返回的一个结果，如果计算失败，则抛出异常
*/
V call() throws Exception;
}执行一个 Runnable 任务，无返回值
/**
* 往线程池提交一个 Runnable 任务，
* 如果线程池已满或线程池关闭则，该任务会交给拒绝处理器处理。
*/
@Override
public void execute(Runnable command) {
if (command == null) {
throw new NullPointerException();
}
// 读取控制变量
int c = ctl.get();
// 1）线程池工作线程数 < 核心线程数
if (ThreadPoolExecutor.workerCountOf(c) < corePoolSize) {
// 尝试创建一个新的工作者线程来处理这个任务
if (addWorker(command, true)) {
// 创建成功则直接返回
return;
}
// 创建失败，则重新读取控制变量
c = ctl.get();
}
/**
* 2）当前工作者线程数 >= 核心工作者线程
* && 线程池处于运行状态
* && 尝试向工作者队列中提交任务
*/
if (ThreadPoolExecutor.isRunning(c) && workQueue.offer(command)) {
// 重新读取控制变量
final int recheck = ctl.get();
// 1）如果线程池已经停止运行，则将目标任务从任务队列中移除，并尝试终止线程池
if (! ThreadPoolExecutor.isRunning(recheck) && remove(command)) {
// 执行拒绝处理器
reject(command);
// 2）如果已经没有可用的工作者线程
} else if (ThreadPoolExecutor.workerCountOf(recheck) == 0) {
// 尝试添加一个新的工作者线程
addWorker(null, false);
}
}
/**
* 3）当前工作者线程数 >= 核心工作者线程
* && 工作队列已满
* && 尝试增加一个新的工作者线程来处理该任务
*/
else if (!addWorker(command, false)) {
// 任务处理失败，则交给拒绝处理器处理
reject(command);
}
}
/**
* 读取线程池的工作线程数
*/
private static int workerCountOf(int c) { return c & ThreadPoolExecutor.COUNT_MASK; }
/**
* 尝试增加一个核心工作者线程来处理这个任务
*/
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (int c = ctl.get();;) {
/**
* 1）线程池状态在 STOP 及以上【线程池已经停止】
* 2）线程池正在停止，并且提交任务不为 null || 工作队列为空
* 则创建失败
*/
if (ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.SHUTDOWN)
&& (ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.STOP)
|| firstTask != null
|| workQueue.isEmpty())) {
return false;
}
for (;;) {
/**
* 1）工作者线程数已经 >= 核心线程数【任务队列未满时】
* 2）工作者线程数已经 >= 最大线程数【任务队列已满时】
* 则创建失败
*/
if (ThreadPoolExecutor.workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & ThreadPoolExecutor.COUNT_MASK)) {
return false;
}
// 尝试递增工作者线程数
if (compareAndIncrementWorkerCount(c)) {
// 如果计数值递增成功，则将正式添加工作者线程来处理任务
break retry;
}
// 如果其他线程优先递增了计数值，则重新读取计数值进行重试
c = ctl.get(); // Re-read ctl
// 线程池正在关闭，则重新进入循环后将直接退出
if (ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.SHUTDOWN))
{
continue retry;
// else CAS failed due to workerCount change; 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 {
/**
* Recheck while holding lock. Back out on ThreadFactory failure or if shut down before lock acquired.
* 读取控制变量再次进行校验
*/
final int c = ctl.get();
/**
* 1）线程池处于运行状态
* 2）线程池处于关闭状态 && 提交任务为 null
*/
if (ThreadPoolExecutor.isRunning(c) ||
ThreadPoolExecutor.runStateLessThan(c, ThreadPoolExecutor.STOP) && firstTask == null) {
// 工作者线程已经启动
if (t.isAlive()) {
throw new IllegalThreadStateException();
}
// 将工作者线程添加到集合中
workers.add(w);
// 如果当前当前工作者线程数 > largestPoolSize，则更新它
final 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;
}
// 运行状态 c 小于指定状态 s
private static boolean runStateLessThan(int c, int s) {
return c < s;
}
// 运行状态 c 大于等于指定状态 s
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
/**
* 尝试原子的将工作者线程数 +1
*/
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
/**
* 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 {
// 1）从 workers 集合中移除工作者 w
if (w != null) {
workers.remove(w);
}
// 递减总工作者线程数
decrementWorkerCount();
// 尝试进行线程池终止
tryTerminate();
} finally {
mainLock.unlock();
}
}
/**
* 将工作者线程总数递减 1
*/
private void decrementWorkerCount() {
ctl.addAndGet(-1);
}
final void tryTerminate() {
for (;;) {
final int c = ctl.get();
/**
* 1）线程池在运行状态【RUNNING】
* 2）线程池在执行清理操作【TIDYING】
* 3）线程池正在停止【SHUTDOWN】并且工作队列非空
* 直接返回
*/
if (ThreadPoolExecutor.isRunning(c) ||
ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.TIDYING) ||
ThreadPoolExecutor.runStateLessThan(c, ThreadPoolExecutor.STOP) && ! workQueue.isEmpty()) {
return;
}
/**
* 工作者线程数不为 0，则强制中断还在运行的工作者
*/
if (ThreadPoolExecutor.workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ThreadPoolExecutor.ONLY_ONE);
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 将控制变量设置为 TIDYING
if (ctl.compareAndSet(c, ThreadPoolExecutor.ctlOf(ThreadPoolExecutor.TIDYING, 0))) {
try {
// 执行线程池的终止钩子函数
terminated();
} finally {
// 将控制变量设置为 TERMINATED
ctl.set(ThreadPoolExecutor.ctlOf(ThreadPoolExecutor.TERMINATED, 0));
// 唤醒在 termination 阻塞的所有线程
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
/**
* 线程池是否在运行
*/
private static boolean isRunning(int c) {
return c < ThreadPoolExecutor.SHUTDOWN;
}
private void interruptIdleWorkers(boolean onlyOne) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 遍历所有的工作者
for (final Worker w : workers) {
// 读取工作者驻留线程
final Thread t = w.thread;
// 如果其为中断，则获取锁并将线程中断
if (!t.isInterrupted() && w.tryLock()) {
try {
t.interrupt();
} catch (final SecurityException ignore) {
} finally {
w.unlock();
}
}
// 如果只中断一个工作者线程，则退出
if (onlyOne) {
break;
}
}
} finally {
mainLock.unlock();
}
}
/**
* 合并工作线程数和运行状态
*/
private static int ctlOf(int rs, int wc) { return rs | wc; }提交一个 Runnable、Callable 任务，有返回值
public abstract class AbstractExecutorService implements ExecutorService {
/**
* 将 Runnable 任务和 T 封装成一个 FutureTask 实例
*/
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
/**
* 将一个 Callable 任务封装成一个 FutureTask 实例
*/
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
return new FutureTask<T>(callable);
}
/**
* 往线程池提交一个 Runnable 任务，无默认计算结果
*/
@Override
public Future<?> submit(Runnable task) {
if (task == null) {
throw new NullPointerException();
}
// 将 Runnable 任务封装成 RunnableFuture
final RunnableFuture<Void> ftask = newTaskFor(task, null);
// 执行任务
execute(ftask);
// 返回一个 Future 对象以异步读取计算结果
return ftask;
}
/**
* 往线程池提交一个 Runnable 任务，有默认计算结果
*/
@Override
public <T> Future<T> submit(Runnable task, T result) {
if (task == null) {
throw new NullPointerException();
}
final RunnableFuture<T> ftask = newTaskFor(task, result);
execute(ftask);
return ftask;
}
/**
* 往线程池提交一个 Callable 任务，自带计算结果
*/
@Override
public <T> Future<T> submit(Callable<T> task) {
if (task == null) {
throw new NullPointerException();
}
final RunnableFuture<T> ftask = newTaskFor(task);
execute(ftask);
return ftask;
}
}
/**
* 可取消的异步计算类
* 1）计算任务可以通过调用 cancel() 方法进行取消。
* 2）如果计算未完成，则 get() 操作将一直阻塞直到计算完成。
* 3）已经完成的计算不能取消、不能再次启动。
*/
public class FutureTask<V> implements RunnableFuture<V> {
/**
* 任务的状态以及可能的状态转换：
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
*/
private volatile int state;
// 新建任务
private static final int NEW = 0;
// 任务正在执行
private static final int COMPLETING = 1;
// 任务正常执行完成
private static final int NORMAL = 2;
// 任务异常执行完成
private static final int EXCEPTIONAL = 3;
// 任务已经被取消
private static final int CANCELLED = 4;
// 任务正在中断
private static final int INTERRUPTING = 5;
// 任务已经中断
private static final int INTERRUPTED = 6;
/** 实际运行的任务载体 */
private Callable<V> callable;
/** 任务的计算结果或异常对象 */
private Object outcome;
/** 运行 Callable 计算任务的线程 */
private volatile Thread runner;
/** 在当前任务上阻塞等待的线程 */
private volatile WaitNode waiters;
/**
* 执行目标 Callable 任务并返回其计算结果
*/
public FutureTask(Callable<V> callable) {
if (callable == null) {
throw new NullPointerException();
}
this.callable = callable;
this.state = FutureTask.NEW;
}
/**
* 执行目标 Runnable 任务并返回指定的计算结果 result
*/
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
// 写入任务状态
this.state = FutureTask.NEW;
}
}
Executors#
/**
* 将 Runnable 封装成一个【执行目标 Runnable 任务并返回计算结果 null 的 Callable 实例】
*/
public static Callable<Object> callable(Runnable task) {
if (task == null) {
throw new NullPointerException();
}
return new RunnableAdapter<>(task, null);
}
/**
* Runnable 到 Callable 的适配器
*/
private static final class RunnableAdapter<T> implements Callable<T> {
// 目标任务的
private final Runnable task;
// 固定的计算结果
private final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
/**
* 运行目标任务并返回固定的计算结果
* created by ZXD at 9 Dec 2018 T 12:24:43
* @return
*/
@Override
public T call() {
task.run();
return result;
}
@Override
public String toString() {
return super.toString() + "[Wrapped task = " + task + "]";
}
}
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
private static final long serialVersionUID = 6138294804551838833L;
/** 线程池中工作者的驻留线程，创建失败时为 null */
final Thread thread;
/** 第一个运行的任务，可能为 null */
Runnable firstTask;
/** 每个驻留线程完成的任务数，在线程退出时会累加到线程池中 */
volatile long completedTasks;
// TODO: switch to AbstractQueuedLongSynchronizer and move
// completedTasks into the lock word.
/**
* 基于指定的初始任务和线程工厂创建工作者线程
*/
Worker(Runnable firstTask) {
// 禁止中断，直到工作者线程运行为止
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
/**
* Worker 本身实现了 Runnable 并且重写了 run 方法，
* 基于 Worker 创建驻留线程，并启动运行。
*/
thread = getThreadFactory().newThread(this);
}
/** 运行工作者线程 */
@Override
public void run() {
runWorker(this);
}
}
Executors#
/**
* 默认的线程工厂
*/
private static class DefaultThreadFactory implements ThreadFactory {
// 线程池计数器
private static final AtomicInteger poolNumber = new AtomicInteger(1);
// 线程组
private final ThreadGroup group;
// 工作者线程计数器
private final AtomicInteger threadNumber = new AtomicInteger(1);
// 工作者线程名称前缀
private final String namePrefix;
DefaultThreadFactory() {
// 读取安全管理器
final SecurityManager s = System.getSecurityManager();
// 读取线程组
group = s != null ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
// 写入工作者线程名称前缀，如：pool-1-thread-
namePrefix = "pool-" +
DefaultThreadFactory.poolNumber.getAndIncrement() +
"-thread-";
}
/**
* 基于目标 Runnable 创建线程
* created by ZXD at 9 Dec 2018 T 12:55:21
* @param r
* @return
*/
@Override
public Thread newThread(Runnable r) {
// 创建线程
final Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
// 设置为非守护线程
if (t.isDaemon()) {
t.setDaemon(false);
}
// 设置线程优先级为 Thread.NORM_PRIORITY
if (t.getPriority() != Thread.NORM_PRIORITY) {
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
}工作者线程核心逻辑
/**
* 工作者线程的核心循环，重复的从任务队列中读取任务并执行。
*/
final void runWorker(Worker w) {
// 读取当前线程
final Thread wt = Thread.currentThread();
// 读取第一个任务
Runnable task = w.firstTask;
// 清理
w.firstTask = null;
w.unlock(); // 允许中断
/**
* 是否异常退出
* 1）前置钩子函数抛出异常
* 2）任务执行时抛出异常
* 3）后置钩子函数抛出异常
*/
boolean completedAbruptly = true;
try {
// 1）尝试从工作队列中读取任务
while (task != null || (task = getTask()) != null) {
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
*
* 1）如果线程池已经停止 && 当前线程未被中断，则中断当前线程
*
*/
if ((ThreadPoolExecutor.runStateAtLeast(ctl.get(), ThreadPoolExecutor.STOP) ||
Thread.interrupted() &&
ThreadPoolExecutor.runStateAtLeast(ctl.get(), ThreadPoolExecutor.STOP)) &&
!wt.isInterrupted()) {
wt.interrupt();
}
try {
/**
* 线程池钩子函数，在每个任务执行之前触发
*/
beforeExecute(wt, task);
try {
task.run();
/**
* 线程池钩子函数，在每个任务执行之后或执行异常时触发
*/
afterExecute(task, null);
} catch (final Throwable ex) {
afterExecute(task, ex);
throw ex;
}
} finally {
// 将当前任务置空
task = null;
// 递增累积完成任务数
w.completedTasks++;
w.unlock();
}
}
// 正常完成任务
completedAbruptly = false;
} finally {
// 处理工作者线程退出后的统计和清理工作
processWorkerExit(w, completedAbruptly);
}
}
/**
* 阻塞读取任务或超时读取任务。
* 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 (;;) {
// 读取控制变量
final int c = ctl.get();
/**
* 1）线程池已经停止
* 2）线程池正在停止 && 任务队列为空
* 都需要返回 null 以终止当前工作者线程
*/
if (ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.SHUTDOWN)
&& (ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.STOP) || workQueue.isEmpty())) {
decrementWorkerCount();
return null;
}
// 计算当前工作者线程数
final int wc = ThreadPoolExecutor.workerCountOf(c);
/**
* 是否允许当前工作者线程退出
* 1）允许核心工作者线程退出
* 2）当前工作者线程数 > 核心工作者线程数
*/
final boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
/**
* 1）当前工作者线程数 > 最大工作者线程数 ||
* 2）允许工作者线程退出 && 当次拉取任务超时
* 3）当前工作者线程数 > 1 || 任务队列为空
*/
if ((wc > maximumPoolSize || timed && timedOut)
&& (wc > 1 || workQueue.isEmpty())) {
// 递减工作者线程数
if (compareAndDecrementWorkerCount(c)) {
// 返回 null 以终止该工作者线程
return null;
}
continue;
}
try {
/**
* 1）如果是超时模式，则尝试在 keepAliveTime 纳秒内读取任务，允许当前工作者退出
* 2）否则，阻塞读取任务【不允许当前工作者退出】
*/
final Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
// 返回任务不为 null，则执行它
if (r != null) {
return r;
}
// 设置超时拉取标识，第二次循环中当前工作者可能退出
timedOut = true;
} catch (final InterruptedException retry) {
timedOut = false;
}
}
}
private void processWorkerExit(Worker w, boolean completedAbruptly) {
// 如果是异常退出，则递减工作者线程数
if (completedAbruptly) {
decrementWorkerCount();
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 将当前工作者 w 完成的任务数累加到线程池已完成任务数中
completedTaskCount += w.completedTasks;
// 从工作者集合中删除该工作者
workers.remove(w);
} finally {
mainLock.unlock();
}
// 尝试终止线程池
tryTerminate();
final int c = ctl.get();
// 线程池处于 RUNNING 或 SHUTDOWN
if (ThreadPoolExecutor.runStateLessThan(c, ThreadPoolExecutor.STOP)) {
// 如果不是异常退出
if (!completedAbruptly) {
/**
* 计算需要保留的最小工作者线程数，如果允许核心工作者线程退出则为 0；
* 否则为 corePoolSize
*/
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
// 任务队列不为空，则至少保留一个工作者线程
if (min == 0 && ! workQueue.isEmpty()) {
min = 1;
}
// 已有工作者线程 > 期望工作者线程数，则直接返回
if (ThreadPoolExecutor.workerCountOf(c) >= min)
{
return; // replacement not needed
}
}
// 否则尝试新增工作者线程
addWorker(null, false);
}
}工作者线程退出的情况
1）线程池前置钩子函数 beforeExecute 或后置钩子函数 afterExecute 执行抛出异常
2）任务运行过程中出现异常
3）允许核心工作者线程退出 && 在 keepAliveTime 纳秒内没有读取到任何任务 && (当前工作者线程数 > 1 || 任务队列为空)
4）当前工作者线程数 > 核心工作者线程数 && 在 keepAliveTime 纳秒内没有读取到任何任务 && (当前工作者线程数 > 1 || 任务队列为空)线程池拒绝策略
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() { }
/**
* 如果线程池还在运行，则在任务提交线程中运行被拒绝的任务
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
// 默认的拒绝执行处理器
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() { }
/**
* 不管线程池的运行状态，丢弃被拒绝的任务，并抛出 RejectedExecutionException 异常
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() { }
/**
* 静默丢弃被拒绝的任务
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() { }
/**
* 如果线程池还在运行，则拉取并丢弃下一个任务，并将被拒绝的任务重新提交
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}线程池的关闭
@Override
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 当前线程是否允许关闭线程池
checkShutdownAccess();
// 将线程池状态更新为 SHUTDOWN
advanceRunState(ThreadPoolExecutor.SHUTDOWN);
// 中断所有空闲工作者，正在处理任务的工作者线程可以继续运行
interruptIdleWorkers();
// 执行钩子函数
onShutdown(); // hook for ScheduledThreadPoolExecutor
} finally {
mainLock.unlock();
}
// 尝试终止线程池
tryTerminate();
}
@Override
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// 当前线程是否允许关闭线程池
checkShutdownAccess();
// 将线程池状态更新为 STOP
advanceRunState(ThreadPoolExecutor.STOP);
// 强制中断所有工作者线程，包括正在执行任务的线程
interruptWorkers();
// 读取所有未完成的任务
tasks = drainQueue();
} finally {
mainLock.unlock();
}
// 尝试终止线程池
tryTerminate();
// 返回所有未完成的任务
return tasks;
}预启动核心工作者线程，以提高响应速度
/**
* 尝试预先启动一个核心工作者线程，阻塞等待获取任务，启动成功返回 true
*/
public boolean prestartCoreThread() {
return ThreadPoolExecutor.workerCountOf(ctl.get()) < corePoolSize &&
addWorker(null, true);
}
/**
* 预启动所有核心工作者线程，并返回实际启动的线程数
*/
public int prestartAllCoreThreads() {
int n = 0;
while (addWorker(null, true)) {
++n;
}
return n;
}状态查询和参数更新
/**
* 线程池是否处于 SHUTDOWN 及以上状态
*/
@Override
public boolean isShutdown() {
return ThreadPoolExecutor.runStateAtLeast(ctl.get(), ThreadPoolExecutor.SHUTDOWN);
}
/**
* 线程池是否处于 STOP 及以上状态
*/
boolean isStopped() {
return ThreadPoolExecutor.runStateAtLeast(ctl.get(), ThreadPoolExecutor.STOP);
}
/**
* 线程池是否正在停止
*/
public boolean isTerminating() {
final int c = ctl.get();
return ThreadPoolExecutor.runStateAtLeast(c, ThreadPoolExecutor.SHUTDOWN) && ThreadPoolExecutor.runStateLessThan(c, ThreadPoolExecutor.TERMINATED);
}
/**
* 线程池是否已经停止
*/
@Override
public boolean isTerminated() {
return ThreadPoolExecutor.runStateAtLeast(ctl.get(), ThreadPoolExecutor.TERMINATED);
}
/**
* 更新核心线程数，可能导致工作线程增加或退出
*/
public void setCorePoolSize(int corePoolSize) {
if (corePoolSize < 0 || maximumPoolSize < corePoolSize) {
throw new IllegalArgumentException();
}
// 计算增量
final int delta = corePoolSize - this.corePoolSize;
// 写入核心线程数
this.corePoolSize = corePoolSize;
// 如果旧的核心线程数比较大，则尝试中断空闲工作者
if (ThreadPoolExecutor.workerCountOf(ctl.get()) > corePoolSize) {
interruptIdleWorkers();
} else if (delta > 0) {
/**
* 计算所需的工作者线程，最大为 delta
*/
int k = Math.min(delta, workQueue.size());
while (k-- > 0 && addWorker(null, true)) {
// 队列为空，则无需增加
if (workQueue.isEmpty()) {
break;
}
}
}
}
/**
* 设置最大工作者线程数
*/
public void setMaximumPoolSize(int maximumPoolSize) {
if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize) {
throw new IllegalArgumentException();
}
this.maximumPoolSize = maximumPoolSize;
// 当前工作者线程数 > 新的最大工作者线程数
if (ThreadPoolExecutor.workerCountOf(ctl.get()) > maximumPoolSize) {
interruptIdleWorkers();
}
}
/**
* 更新空闲线程存活时间
*/
public void setKeepAliveTime(long time, TimeUnit unit) {
if (time < 0) {
throw new IllegalArgumentException();
}
if (time == 0 && allowsCoreThreadTimeOut()) {
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
}
// 计算新的空闲线程存活时间
final long keepAliveTime = unit.toNanos(time);
// 计算增量
final long delta = keepAliveTime - this.keepAliveTime;
// 写入值
this.keepAliveTime = keepAliveTime;
if (delta < 0) {
interruptIdleWorkers();
}
}
/**
* 设置拒绝执行处理器
*/
public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
if (handler == null) {
throw new NullPointerException();
}
this.handler = handler;
}
/**
* 设置工作者线程工厂
*/
public void setThreadFactory(ThreadFactory threadFactory) {
if (threadFactory == null) {
throw new NullPointerException();
}
this.threadFactory = threadFactory;
}
/**
* 设置允许核心工作者线程退出，为 true 时 keepAliveTime 必须 > 0
*/
public void allowCoreThreadTimeOut(boolean value) {
if (value && keepAliveTime <= 0) {
throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
}
// 尝试更新值
if (value != allowCoreThreadTimeOut) {
allowCoreThreadTimeOut = value;
if (value) {
interruptIdleWorkers();
}
}
}