前言
众所周知，JDK为我们提供了一系列线程池类，ThreadPoolExecutor就是一个很典型的实现，以下对JDK的线程池机制分析都将围绕这一个类来描述。
开始
要使用ThreadPoolExecutor，我通常会这样做：
//创建一个核心线程数为4的线程池
ExecutorService es = Executors.newFixedThreadPool(4);
Task t = new Task();
for (int i = 0; i < 100; i++) {
es.submit(t);
}
es.shutdown();
但是这里面发生了什么事，它的代码实现又是怎么一回事呢，我们来一探究竟。
细究
通过对submit方法打断点，我们可以发现，在AbstractExecutorService这个类里边半实现了submit方法
//AbstractExecutorService#submit
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);//mark here
return ftask;
}
为什么我说是“半实现”呢，因为在我mark的那行代码的execute(Runnable)方法仍然是一个抽象方法，在ThreadPoolExecutor类中，提供了对它的具体实现。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
//拿到当前的work（或者说是Runnable）数量
int c = ctl.get();
//如果工作的线程小于核心线程数的话
if (workerCountOf(c) < corePoolSize) {
//addWorker()方法里面会创建Worker类和对应的线程。
if (addWorker(command, true))
return;
c = ctl.get();
}
//如果大于核心线程数，就把这个Runnable对象command加入阻塞队列中，
//同时应该二次检查是否应该创建新的线程，
//如果线程池shutdown，就执行reject操作，就是拒绝服务了。
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);
}
//如果无法加入阻塞队列，直接拒绝服务
else if (!addWorker(command, false))
reject(command);
}
再来看一下addWorker方法。
private boolean addWorker(Runnable firstTask, boolean core) {
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;
for (;;) {
int wc = workerCountOf(c);
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
//用CAS操作成功增加worker数量之后，跳出大循环
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
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
//开始创建Worker
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)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
//执行到这里，Worker就算是创建成功了
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//成功创建Worker之后，启动线程。
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
那这个Worker类到底是一个怎么样的数据结构呢，再来看一下。
当我们创建一个Worker的时候，就把我们通过submit方法传递进来的Runnable给了
firstTask属性，然后再通过工厂方法创建一个线程。同时Worker又是一个Runnable对象，在重写的run()方法中，调用了外部的runWorker(Worker)方法。正如上文所讲的一样，创建了线程就会start()，每个线程所做的就是这里的run方法，再细化，就是
runWorker(Worker)方法
首先，把传递进来的Worker的Runnable对象给task，这时候的task局部对象有两种的取值，一种是我们直接submit进来的Runnable对象，另一种是null，出现null的情况是：当前线程的数量大于等于核心线程数量。
所以，在while循环的时候，我们才会用task != null || (task = getTask() != null)这种表示，getTask方法待会再看，它会在阻塞队列中获取Runnable对象。
拿到了task，就可以调用run方法了，因为我们现在就是在工作的线程里面。
最后，来看看getTask()方法。
getTask方法的外部包着一个死循环for(;;)，这是因为poll方法在阻塞队列空的时候并不会把当前线程阻塞住，它还会往下走。
但是如果boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;这条语句不成立，timed为false，就可以成功的将线程阻塞住，我找遍了ThreadPoolExecutor这个类，都没有找到allowCoreThreadTimeOut这个属性的赋值的地方，那么就默认成立false，所以，在阻塞队列拿Runnable对象就主要是take()方法了。
结尾
正是这样不停向阻塞队列拿Runnable或者创建规定数量的线程执行Runnable的机制，保证了线程池的正常运行，当然我今天记录下来的只是冰山一角，这里面还是有很多地方值得我们去研究，比如AQS类，CAS机制等等。才疏学浅，只敢写下这些了。
