常用方法
核心方法:execute
// command 是一个 Runnable 对象,也就是用户提交执行的任务
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 (存有线程池状态和线程数量)
int c = ctl.get();
// 若当前工作线程数量小于核心池大小(coolPoolSize)
// 则在核心池中新增一个工作线程,并将该任务交给这个线程执行
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
// 重新获取(存在并发可能)
c = ctl.get();
}
// 若执行到这里,表示池中线程数量 >= corePoolSize,或者上面 addWorker 失败
// 若线程池处于 RUNNING 状态,并且该任务(command)成功添加到任务队列
if (isRunning(c) && workQueue.offer(command)) {
// 再次获取 ctl 值
int recheck = ctl.get();
// 若线程池不是运行状态,则要把上面添加的任务从队列中移除并执行拒绝策略
//(可理解为“回滚”操作)
if (! isRunning(recheck) && remove(command))
// 执行拒绝策略
reject(command);
// 若此时池中没有线程,则新建一个
// PS: 这里是防止任务提交后,池中没有存活的线程了
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 根据上述代码分析,若执行到这里,可分为以下两种情况:
// ① 线程池不是 RUNNING 状态;
// ② 线程池处于 RUNNING 状态,且实际线程数量 workCount >= corePoolSize,
// 并且,添加到 workQueue 失败(已满)
// 此时,则需要和 maximumPoolSize 进行比较,
// 若 workCount <= maximumPoolSize, 则新建一个线程去执行该任务;
// 否则,即 workCount > maximumPoolSize (饱和),则执行拒绝策略
else if (!addWorker(command, false))
// 执行拒绝策略
reject(command);
}
该方法描述的就是一个任务提交到线程池的流程,主要执行逻辑如下:
1、若正在运行的线程数少于 corePoolSize,则创建一个新的线程,并将传入的任务(command)作为它的第一个任务执行。
2、若运行的线程数不小于 corePoolSize,则将新来的任务添加到任务队列(workQueue)。若入队成功,仍需再次检查是否需要增加一个线程(上次检查之后现有的线程可能死了,或者进入该方法时线程池 SHUTDOWN 了,此时需要执行回滚);若池中没有线程则新建一个(确保 SHUTDOWN 状态也能执行队列中的任务)。
3、若任务不能入队(队列已满),则创建新的线程并执行任务,若失败(超过 maximumPoolSize),则表示线程池关闭或者已经饱和,因此拒绝该任务。
在线程池中,ctl 贯穿在线程池的整个生命周期中,它是一个原子类,主要作用是用来保存线程数量和线程池的状态。
内部类Worker及其方法:
// 继承自 AQS,且实现了 Runnable 接口
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/** Thread this worker is running in. Null if factory fails. */
final Thread thread;
/** Initial task to run. Possibly null. */
// 运行的第一个任务,可能为空
Runnable firstTask;
/** Per-thread task counter */
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); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// 初始化 thread
this.thread = getThreadFactory().newThread(this);
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
// 其他一些 AQS 相关的方法不再一一列举
}
addWorker 方法:
在execute方法里可以看到这个方法,如果工作线程数小于核心线程数的话,会调用 addWorker,顾名思义,其实就是要创建一个工作线程。
// firstTask: 第一个任务,可为空
// core: 是否为核心池,true 是,false 为最大池
private boolean addWorker(Runnable firstTask, boolean core) {
// 该循环的主要作用就是增加 workCount 计数,增加成功后再新增 Worker 对象
retry://goto 语句,避免死循环
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
/*
* rs >= SHUTDOWN 表示线程池不再接受新的任务
* 该判断条件分为以下三种:
* ① 线程池处于 STOP, TYDING 或 TERMINATED 状态;
* ② 线程池处于 SHUTDOWN 状态,且 firstTask 不为空;
* ③ 线程池处于 SHUTDOWN 状态,且 workQueue 为空
* 满足任一条件即返回 false.
*/
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {//自旋
int wc = workerCountOf(c);
// 超出最大容量 CAPACITY,或者超出初始设置的核心池/最大池数量,则返回 false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// CAS 方式增加 ctl 的 workerCount 数量(该循环的主要目的)
if (compareAndIncrementWorkerCount(c))
break retry; // 若增加失败则退出循环
c = ctl.get(); // Re-read ctl
// 运行状态改变
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 {
// 将 firstTask 封装成 Worker 对象
w = new Worker(firstTask);
// 获取 thread 对象 t
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.
int rs = runStateOf(ctl.get());
// 若线程池状态小于 SHUTDOWN,即为 RUNNING 状态;
// 或者为 SHUTDOWN 状态,且 firstTask 为空,
// 表示不再接受新的任务,但会继续执行队列中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 添加到工作线程集合(HashSet)
workers.add(w);
// 更新最大计数
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
// 标记 Worker 添加成功
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 若成功添加到工作线程集合,则启动线程执行任务
if (workerAdded) {
// 启动线程
t.start();
workerStarted = true;
}
}
} finally {
// Worker 启动失败,执行回滚操作
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
addWorker 方法中,如果添加 Worker 并且启动线程失败,则会做失败后的处理。
private void addWorkerFailed(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (w != null)
workers.remove(w);
decrementWorkerCount();
tryTerminate();
} finally {
mainLock.unlock();
}
}
runWorker 方法:
这个方法主要做几件事
1、如果 task 不为空,则开始执行 task
2、如果 task 为空,则通过 getTask()再去取任务,并赋值给 task,如果取到的 Runnable 不为空,则执行该任务
3、执行完毕后,通过 while 循环继续 getTask()取任务
4、如果 getTask()取到的任务依然是空,那么整个 runWorker()方法执行完毕
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//unlock,表示当前 worker 线程允许中断,因为 new Worker 默认的 state=-1,此处是调用
//Worker 类的 tryRelease()方法,将 state 置为 0,
//而 interruptIfStarted()中只有 state>=0 才允许调用中断
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//注意这个 while 循环,在这里实现了 [线程复用] // 如果 task 为空,则通过getTask 来获取任务
while (task != null || (task = getTask()) != null) {
w.lock(); //上锁,不是为了防止并发执行任务,为了在 shutdown()时不终止正在运行的 worker
//线程池为 stop 状态时不接受新任务,不执行已经加入任务队列的任务,还中断正在执行的任务
//所以对于 stop 状态以上是要中断线程的
//(Thread.interrupted() &&runStateAtLeast(ctl.get(), STOP)确保线程中断标志位为 true 且是 stop 状态以上,接着清除了中断标志
//!wt.isInterrupted()则再一次检查保证线程需要设置中断标志位
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);//这里默认是没有实现的,在一些特定的场景中我们可以自己继承 ThreadpoolExecutor 自己重写
Throwable thrown = null;
try {
task.run(); //执行任务中的 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,需要再通过 getTask()取) + 记录该 Worker 完成任务数量 + 解锁
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
//1.将入参 worker 从数组 workers 里删除掉;
//2.根据布尔值 allowCoreThreadTimeOut 来决定是否补充新的 Worker 进数组workers
}
}