1.ThreadPoolExecutor方法解析
1.1 submit(Callable task)方法
public <T> Future<T> submit(Callable<T> task) {//submit方法实际在ThreadPoolExecutor的超类AbstractExecutorService中，该超类实现了ExecutorService接口
if (task == null) throw new NullPointerException();
RunnableFuture<T> ftask = newTaskFor(task);//实际返回的是一个FutureTask类型，FutureTask实现了RunnableFuture接口
execute(ftask);//调用ThreadPoolExecutor中的execute()方法
return ftask;//实际返回类型是一个FutureTask类型
}
1.2 executor(Runnable command)方法
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();//ctl是一个ActomicInteger类型，其高三位维护了线程池的状态，剩余位维护了工作线程的数量
if (workerCountOf(c) < corePoolSize) {//判断工作线程数量小于线程池设置的核心线程的数量
if (addWorker(command, true))//新建工作线程，这里第二个参数指示当前线程池最多允许的工作线程数量，如果为true则代表最多允许的工作线程的数量为corePoolSize,如果为false则代表最多允许的工作线程的数量为maxPoolSize;
return;
c = ctl.get();//并发情况，线程池的状态及工作线程的数量可能发生改变，重新获取ctl
}
if (isRunning(c) && workQueue.offer(command)) {//如果线程池为RUNNING状态，则将提交的任务放入阻塞队列
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))//双重检查，如果任务成功提交到阻塞队列，并且线程池状态已经变为非RUNNING状态，需要将该任务从阻塞队列异常，移除后会手动调用tryTerminate()方法
reject(command);//调用对应的拒绝策略，默认为AbortPolicy，即抛异常
else if (workerCountOf(recheck) == 0)//如果当前工作线程数量为0，则新建工作线程
addWorker(null, false);//第一个参数为null,表示新建时工作线程没有任务，需要到阻塞队列去拿，拿任务的方法为ThreadPoolExecutor的getTask()方法
}
else if (!addWorker(command, false))//如果加入阻塞队列失败(可能阻塞队列已满)，则直接调用addWorker()方法，因为第二个参数传入的false，因此如果当前线程池的工作线程的数量大于等于maxPoolSize则该方法会失败
reject(command);//同上
}
1.3 addWorker(Runnable firstTask, boolean core)
private boolean addWorker(Runnable firstTask, boolean core) {//第一个参数为提交的任务，实际为FutureTask类型，第二个指示了参数表示当前线程池最多可创建的工作线程的数量，如果core=true表示最多可创建数量为corePoolSize，如果core=false表示最多可创建的数量为maxPoolSize
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;//仅当线程池处于以下两种状态时，可以新建工作线程1)线程池为RUNNABLE状态 2)当前线程池状态为SHUTDOW，且提交的任务已经加入到阻塞队列中(此时firstTask为null代表新建的工作线程需要到阻塞队列中去取任务)
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))//如果当前线程池数量大于corePoolSize/maxPoolSize，则返回false
return false;
if (compareAndIncrementWorkerCount(c))//调用ctl的compareAndSet方法将工作线程数量加1,若成功则跳出外层for循环，否则一直重试
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)//如果在此期间线程池的运行状态发生改变，则重新从外层for循环执行
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);//work即为工作线程，其保存了执行任务的线程，以及要执行的任务
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();//内部要修改两个成员变量，分别为记录工作线程集合的workers和本线程池最大工作线程的数量largestPoolSize
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)) {
if (t.isAlive()) //本人认为，这里如果是用的Executors.DefaultThreadFactory，那么每次新建worker都是新建线程，则一定没有调用start()方法，返回false
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;//注意这里要将largestPoolSize与maxPoolSize区分开，largestPoolSize相当于记录当前线程池最多用到了多少个工作线程，其小于等于maxPoolSize
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();//重要!!，此处的thread实际是创建worker时，通过线程工厂创建的，因此其对应的run()方法，应当未Worker类中的run()方法，而不是直接调用的传入的Runnable的run()方法
workerStarted = true;
}
}
} finally {
if (! workerStarted)//如果中间发生异常，则需要将workers即ctl的状态恢复到正确状态
addWorkerFailed(w);
}
return workerStarted;
}
1.4 Worker类的构造方法Worker(Runnable firstTask)
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);//调用线程工厂的newThread()方法，因为此处传入的this实际为本对象(不是firstTask，这里需要注意)，因此addWorker()方法中调用worker的thread.start()方法最终调用的run()方法实际是下面的run()方法
}
/** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);//调用runWorker()方法
}
1.5 runWorker(Worker w)方法
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();//wt其实就是this.thread
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;//指示是否是异常结束，如果下面的while方法运行过程中无异常，则会将变量置为false
try {
while (task != null || (task = getTask()) != null) {//若当前task为空，则需要去阻塞队列拿任务
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
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&//
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())//如果当前线程池正在停止(状态大于等于STOP)，则需要确保wt中断未置位标识为false，注意Thread.interrupted()返回当前线程中断位标记是否为true，并且会清除中断标记
wt.interrupt();//如果置中断位置为true，则会影响FutureTask的get()方法中的awaitNone(boolean timed,long nanos)方法，如果awaitNone(boolean timed,long nanos)方法没有进入到LockSupport.park()/LockSupport.parkNanos()中，则调用FutureTask的get()会产生InterruptedException()异常
try {
beforeExecute(wt, task);//模板模式的钩子方法
Throwable thrown = null;
try {
task.run();//执行FutureTask中的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;//上面没有发生异常，则将该标记位置为false
} finally {
processWorkerExit(w, completedAbruptly);//当没有任务执行时，则调用该方法，本方法会将当前工作线程从workers异常，方法最后调用
addWorker(null, false)
}
}
1.6 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.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {//如果当前线程池状态大于STOP状态，则不会处理任何任务返回false，如果当前线程池状态为SHUTDOW且阻塞队列为空，无任务可执行，同样返回空
decrementWorkerCount();//取不到任务则将工作线程数量减一
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))//wc>maximunPoolSize可以忽略，因为工作线程数量不会大于maximumPoolSize，因此其肯定为false，timeOut初始为false，当从阻塞队列中拿不到任务时置为true
&& (wc > 1 || workQueue.isEmpty())) {
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);//这里的keepAliveTime即为构造线程池时传入的保持线程alive的时间
workQueue.take();
if (r != null)//如果取到任务，则返回
return r;
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}
1.7 processWorkerExit(Worker w, boolean completeAbruptly)方法
private void processWorkerExit(Worker w, boolean completedAbruptly) {
if (completedAbruptly) // 如果非异常结束，则上面的getTask()会将工作线程数减一，否则需要手动减一
decrementWorkerCount();
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);//从工作线程集合中移除该worker
} 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; // //重要!!如果非异常结束，将这里与上面的getTask()方法结合起来，意思就是，如果当前线程池的工作线程数量大于corePoolSize，并且当前工作线程在keepAliveTime时间内都没有任务可执行，则当前工作线程任务完成，光荣下岗
}
addWorker(null, false);//
}
}
1.8 remove(Runnable task)
public boolean remove(Runnable task) {
boolean removed = workQueue.remove(task);
tryTerminate(); // 这里调用tryTerminate()方法
return removed;
}
1.9 tryTerminate()
final void tryTerminate() {
for (;;) {
int c = ctl.get();
if (isRunning(c) ||
runStateAtLeast(c, TIDYING) ||
(runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))//重要！！当且仅当线程池满足1)线程池状态为STOP 2)线程池状态为SHUTDOW且阻塞队列中已经没有任务两个条件之一时，才会继续往下执行，否则将直接返回
return;
if (workerCountOf(c) != 0) { // Eligible to terminate
interruptIdleWorkers(ONLY_ONE);//内部会尝试将一个工作线程的中断标记置为true
return;
}
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {//当程序走到这，说明目前工作线程数量为0
try {
terminated();//钩子方法，默认为空方法，因此如果不重写terminated()方法，则TIDYIN状态和TERMINATED状态可以认为没有任何改变
} finally {
ctl.set(ctlOf(TERMINATED, 0));
termination.signalAll();//唤起因awaitTermination(long timeout,TimeUnit unit)而阻塞的方法
}
return;
}
} finally {
mainLock.unlock();
}
// else retry on failed CAS
}
1.10 reject(Runnable command)方法
final void reject(Runnable command) {
handler.rejectedExecution(command, this);//根据对应的拒绝策略执行对应的逻辑，默认的拒绝策略为ThreadPoolExecutor.AbortPolicy即扔出异常。
}
