ThreadPoolExecutor.execute 源码解读
1.execute（Runnable），任务提交方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//ctl:记录线程池是生命周期状态和当前工作线程数;
int c = ctl.get();
//workerCountOf(c):工作线程数；corePoolSize：核心线程数
if (workerCountOf(c) < corePoolSize) {
//在线程池状态>=SHUTDOWN后或者工作线程数大于核心线程数时添加失败
if (addWorker(command, true))//true 与核心线程数绑定（添加核心线程）
return;
c = ctl.get();//刷新
}
//如果是运行状态 和任务添加成功
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//检查以及移除
if (! isRunning(recheck) && remove(command))
//拒绝任务策略，默认是抛出RejectedExecutionException异常
reject(command);
//如果当前没有工作线程
else if (workerCountOf(recheck) == 0)
//在线程池状态>=STOP时或者工作线程数>最大线程数时，返回false
addWorker(null, false);//false:与最大线程数绑定(添加非核心线程)
}
//在线程池状态>=SHUTDOWN时或者工作线程数>最大线程数时，返回false
else if (!addWorker(command, false))//false:与最大线程数绑定(添加非核心线程)
reject(command);//拒绝任务
}
2.addWorker 添加工作线程
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
//RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
//当运行状态>SHUTDOWN 时,不再接收新任务，也不再处理队列中的任务，返回false
//当运行状态为SHUTDOWN时:
// 任务队列为空时，return false;
// fisrtTask不为null时(想要添加任务)，返回false；如果为null，则表示想新建一个工作线程去完成队 // 列中的任务
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
//获取工作线程数
int wc = workerCountOf(c);
//工作线程大于等于CAPACITY(536870911)时，
//或者(core=true，大于核心线程数;core为false,大于最大线程数时 直接返回false)
//所以，线程池最大线程数取值上限为536870911？
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//工作线程数+1，如果成功，直接跳出最外层(retry标记的循环)
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
//运行是否和外层循环获取的一致，不一致，则continue(retry标记的循环)，重新定义状态
if (runStateOf(c) != rs)
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.
// 运行状态
int rs = runStateOf(ctl.get());
//再次判断是否可以创建工作线程
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
//isAlive==true代表 线程已经start()过，因为下面会再次start，这是不合法的
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
//记录当前线程池最大容量(工作线程的数量)，
if (s > largestPoolSize)
largestPoolSize = s;//可以通过getLargestPoolSize。。。获取
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//start.等到执行run方法时，执行的Worker的run方法，里面调用了runWorker方法
//this.thread = getThreadFactory().newThread(this);this是worker(实现于Runnable)
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
//未启动处理，删除工作线程，工作线程数减1，
addWorkerFailed(w);
}
return workerStarted;
}
3.runWorker
addWorker中 t.start -> Worker.run->Worker.runWorker
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
//unlock,之后 state=0，在shutdownNow时，getState>0时，才可以中断线程
w.unlock(); // allow interrupts
//异常终止
boolean completedAbruptly = true;
try {
//getTask();获取任务，是一个阻塞方法
while (task != null || (task = getTask()) != null) {
w.lock();//state=1
//1：如果线程状态>=STOP 且线程未中断，则中断当前线程
//2:否则Thread.interrupted()，如果当前线程是中断状态，则取消中断状态，返回true
//该中断时，没中断，中断线程；不该中断时，中断了，取消中断标记
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&//取消中断标记后，重新检查运行状态
!wt.isInterrupted
wt.interrupt();
try {
//如有必要，自己实现，默认啥都不做
beforeExecute(wt, task);
Throwable thrown = null;
try {
//这里的task 是Worker
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;
//完成任务量+1
w.completedTasks++;
w.unlock();
}
}
//正常结束
completedAbruptly = false;
} finally {
//停止工作线程
processWorkerExit(w, completedAbruptly);
}
}
4：getTask 从队列中获取任务
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.
//在RUNNING和(SHUTDOWN且任务队列不为空时)通过
if (rs >= SHUTDOWN
&& (rs >= STOP || workQueue.isEmpty())) {
decrementWorkerCount();//工作线程数减1
return null; }
int wc = workerCountOf(c);
// Are workers subject to culling?
//timed==true时，当前线程获取超时会退出(poll())
//非核心线程超时会退出，如果允许，核心线程也会如此，
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
//1:如果有任务，至少会留一个干活(就算超时或是超出最大容量)，
//2:wc > maximumPoolSize,,最大线程数是可以运行时设置的，当减少时，会有这种情况
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
//workQueue.poll();获取任务,超时唤醒退出(多余线程回收机制)
//keepAliveTime 默认是60s,如果阻塞时间超过这个时间,就是超时了
//workQueue.take() 如果获取不到任务会一直阻塞，可以中断唤醒
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();
if (r != null)
return r;
//超时了
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}}
5.结束工作线程方法
private void processWorkerExit(Worker w, boolean completedAbruptly) {
//异常结束，工作线程数减-1
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();
//如果运行状态为 RUNNING或SHUTDOWN
if (runStateLessThan(c, STOP)) {
//如果正常结束
if (!completedAbruptly) {
//允许的最少线程数量(如果允许核心线程超时的话，工作线程最少为0，否则为核心线程)
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
//如果任务队列不为空且允许核心线程数超时
if (min == 0 && ! workQueue.isEmpty())
min = 1;//因为还有任务要做，要保证最小线程数量至少为1;
//如果工作线程数量>=最小线程数量
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//如果异常结束，或者当前工作线程数小于最小允许的线程数，新建一个工作线程
addWorker(null, false);
}
}
6.tryTerminate 尝试停止线程池
final void tryTerminate() {
for (;;) {
int c = ctl.get();
//1:如果线程状态为RUNNING(异常结束走到这？),直接return;
//2:如果线程状态为TIDYING及TERMINATED时(线程池已经停止了),return
//3:状态为SHUTDOWN且队列不为空，return,接着干活
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
return;
//怎么样才能走到这里？1：状态为STOP,2：状态为shutdown且任务队列为空
//如果此时工作线程不等于0
if (workerCountOf(c) != 0) { // Eligible to terminate
//中断一个线程(不一定是当前工作线程)
interruptIdleWorkers(ONLY_ONE);
//返回，让其他工作线程去停止线程池
return;
}
//此时任务队列为空，工作线程也全部停止了
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
//设置运行状态为TIDYING,如果设置成功，
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
try {
// Default implementation does nothing
//执行钩子函数，执行完之后
terminated();
} finally {
//设置状态为TERMINATED
ctl.set(ctlOf(TERMINATED, 0));
//Wakes up all waiting threads.唤醒所有等待的线程,
//如果未调用awaitTermination()方法，则无用？
//awaitTermination()->termination.awaitNanos(nanos);唤醒这类wait方法等待的线程
termination.signalAll();
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
}
