先来看ThreadPoolExecutor的execute方法，这个方法能体现出一个Task被加入到线程池之后都发生了什么：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/* 如果运行中的worker线程数少于设定的常驻线程数，增加worker线程，把task分配给新建的worker线程 */
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 如果任务可以被加入到任务队列中，即等待的任务数还在允许的范围内，
// 再次检查线程池是否被关闭，如果关闭的话，则移除任务并拒绝该任务
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 如果任务数超过了现有worker线程的承受范围，尝试新建worker线程
// 如果无法添加新的worker线程，则会拒绝该任务
else if (!addWorker(command, false))
reject(command);
}
在执行任务时，需要经常检查线程池的状态，那么接下来说说线程池是如何进行状态控制的。上面的代码有个成员变量叫做ctl，它用于标记线程池状态和worker线程的数量，是一个AutomaticInteger对象。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
ctl是一个32位的整数，最高的3位表示状态：
111为running，
000为shutdown，
001为stop，
010为tidying，
011为ternimated。
因此状态值就是这三位加上29个0，因此running的值是个负整数（最高位为1），其他状态都是正整数，后面判断状态会比较值的大小时会用到这点。
剩下的29位表示worker线程的数量（因此最大允许的线程数就是2的29方减1）。
这里是说说这几个状态的意义，这几个状态发生的顺序正好就是上面列出的顺序：
running表示正常运行状态
shutdown状态意味着发出了一个shutdown信号，类似于你点击了windows的关机按钮
stop表示shutdown信号收到，等于windows响应了这个信号，发出正在关机的信息
tidying发生在stop之后做出的响应，表示这个时候在清理一些资源，
ternimated发生在tidying完成之后，表示关闭完成。
接着来看添加一个worker线程时都发生了什么：
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// 返回false的情况：
// 1. rs>shutdown，即shutdown和running以外的状态
// 2. shutdown的状态
// 1）firstTask不为null，即有task分配
// 2）没有task，但是workQueue（等待任务队列）为空
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
// 1. 如果没有设定线程数的限制，worker线程数不能大于最大值（2的29次方-1）
// 2. 如果是固定尺寸的线程池，不能大于固定尺寸
// 3. 如果是可扩展的线程池，不能大于规定的线程数的上限
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
// 用CAS操作增加线程数量，如果失败，重新循环
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
loop
}
}
// 新建worker线程
Worker w = new Worker(firstTask);
Thread t = w.thread;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int c = ctl.get();
int rs = runStateOf(c);
// 检查以下任一状态是否出现：
// 1. 创建线程失败
// 2. rs>shutdown，即shutdown和running以外的状态
// 3. rs==shutdown，有任务分配
if (t == null ||
(rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null))) {
decrementWorkerCount();
tryTerminate();
return false;
}
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
} finally {
mainLock.unlock();
}
t.start();
// 这里考虑一种极少出现的情况，如果worker线程调用start没有完成时，
// 线程池进入Stop状态，这个时候会调用Thread#interrupt中断每个
// worker线程，但是 interrupt对没有start的线程不一定起作用，这样
// 就会漏掉了对这个thread的interrupt，因此在worker线程start之后
// 检查以下，如果stop了，而这个线程却没有被interrupt，补上这个漏掉
// 的interrupt。
if (runStateOf(ctl.get()) == STOP && ! t.isInterrupted())
t.interrupt();
return true;
}
这篇文章主要讲线程池如何处理任务，下一篇文章将会讲worker线程是如何工作的。
