【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> 
我之前一篇文章谈到了ThreadPoolExecutor的作用（http://my.oschina.net/xionghui/blog/494004），这篇文章介绍下它的原理，并根据原理分析下它的实现源码。
我们先来查看一下ThreadPoolExecutor API，看看它能实现什么功能，然后看看它是怎么实现这些功能的。
ThreadPoolExecutor API
ThreadPoolExecutor API比较长，这里列出几个关键点：
核心和最大池大小：如果运行的线程少于 corePoolSize，则创建新线程来处理请求（即一个Runnable实例），即使其它线程是空闲的。如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程。
保持活动时间：如果池中当前有多于 corePoolSize 的线程，则这些多出的线程在空闲时间超过 keepAliveTime 时将会终止。
排队：如果运行的线程等于或多于 corePoolSize，则 Executor 始终首选将请求加入队列BlockingQueue，而不添加新的线程。
被拒绝的任务：当 Executor 已经关闭，或者队列已满且线程数量达到maximumPoolSize时（即线程池饱和了），请求将被拒绝。
好，ThreadPoolExecutor实现的功能确实很多，咱们来屡屡ThreadPoolExecutor 的执行过程：
如果运行的线程少于 corePoolSize，ThreadPoolExecutor 会始终首选创建新的线程来处理请求；注意，这时即使有空闲线程也不会重复使用（这和数据库连接池有很大差别）。
如果运行的线程等于或多于 corePoolSize，则 ThreadPoolExecutor 会将请求加入队列BlockingQueue，而不添加新的线程（这和数据库连接池也不一样）。
如果无法将请求加入队列（比如队列已满），则创建新的线程来处理请求；但是如果创建的线程数超出 maximumPoolSize，在这种情况下，请求将被拒绝。
到这儿大家应该了解了线程池的大概执行过程，下面通过源码来介绍下ThreadPoolExecutor是如何实现这些过程和功能的。在理解源码前咱们先来考虑几个问题：
线程池里的线程如何重复利用？比如一个线程执行完请求，怎么控制不退出。
线程池空闲时线程池里的线程数量会不会降到0？
线程池如何保持活动时间？线程可以设置一段时间内闲置就会退出（通过keepAliveTime 设置）。
线程池的阻塞队列有什么用？
请求数量太多如何处理过多的请求？
ThreadPoolExecutor源码
首先看下线程池的执行过程：
execute(Runnable command)是ThreadPoolExecutor的核心处理方法，用于处理Runnable 请求。
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}poolSize为线程池内启动的线程数量，当线程池的poolSize小于核心池corePoolSize时，会去执行addIfUnderCorePoolSize(command)，addIfUnderCorePoolSize(Runnable firstTask)会创建一个新线程来处理请求：
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}可以看到，首先加锁（默认是非公平锁）已保证线程安全，然后会进行double check，状态合法则创建新线程。创建新线程处理任务是通过addThread(Runnable firstTask)方法来完成：
private Thread addThread(Runnable firstTask) {
Worker w = new Worker(firstTask);
Thread t = threadFactory.newThread(w);
if (t != null) {
w.thread = t;
workers.add(w);
int nt = ++poolSize;
if (nt > largestPoolSize)
largestPoolSize = nt;
}
return t;
}可以看到创建线程时使用了内部类Worker封装了请求Runnable，Worker也是一个Runnable，它封装了firstTask请求，作用后面再介绍。
这里先介绍下通过threadFactory创建新线程的过程：threadFactory是可以自定义的（通过ThreadPoolExecutor 的构造函数传入），默认会使用DefaultThreadFactory，再来看看DefaultThreadFactory是如何创建新线程的：
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}代码很明朗，创建了一个线程，设置为非守护线程并设置优先级为5。其中group和namePrefix是在DefaultThreadFactory的构造函数中定义的：
group = (s != null)? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";现在回到addIfUnderCorePoolSize(Runnable firstTask)方法，创建完线程后会直接start，然后就会调用Work的run()方法，这里介绍下Work的作用：
public void run() {
try {
Runnable task = firstTask;
firstTask = null;
while (task != null || (task = getTask()) != null) {
runTask(task);
task = null;
}
} finally {
workerDone(this);
}
}其中firstTask就是execute(Runnable command)方法传入的请求，可以看到，如果firstTask不为空，则直接执行，否则会通过getTask()从阻塞队列中获取等待的任务；到这里可以解答第一个问题了：线程池里的线程如何重复利用？一个线程会执行多个请求（即Runnable），当执行完一个请求后会通过getTask()去获取新的请求来执行（是从阻塞队列中获取，后面会介绍）。下面看看getTask()方法：
Runnable getTask() {
for (;;) {
try {
int state = runState;
if (state > SHUTDOWN)
return null;
Runnable r;
if (state == SHUTDOWN) // Help drain queue
r = workQueue.poll();
else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
else
r = workQueue.take();
if (r != null)
return r;
if (workerCanExit()) {
if (runState >= SHUTDOWN) // Wake up others
interruptIdleWorkers();
return null;
}
// Else retry
} catch (InterruptedException ie) {
// On interruption, re-check runState
}
}
}挑重点介绍：当poolSize小于或等于corePoolSize时，会通过workQueue.take()一直等待，直到workQueue添加新的Runnable，到这里可以解答第二个问题了：线程池空闲时线程池里的线程数量会不会降到0？答案是如果线程池里的线程数量小于或等于核心线程数（corePoolSize）则不会退出任何线程。
然而当poolSize大于corePoolSize时或通过workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)等待keepAliveTime(ns)，这里可以解答第三个问题了：线程池如何保持活动时间?答案是通过阻塞队列workQueue控制。
这里需要注意下，当poolSize大于corePoolSize时且在keepAliveTime内没有获得新的请求，则会判断当前线程是否需要退出，通过workerCanExit()来判断：
private boolean workerCanExit() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
boolean canExit;
try {
canExit = runState >= STOP ||
workQueue.isEmpty() ||
(allowCoreThreadTimeOut &&
poolSize > Math.max(1, corePoolSize));
} finally {
mainLock.unlock();
}
return canExit;
}从上面可以看到线程退出的条件为：运行状态大于STOP，或者阻塞队列为空，或者当前线程数大于核心线程数。达到条件则返回false，此时getTask()会返回空，然后Work的run()方法里面的while循环则会退出，线程此时会退出并销毁。注意，退出前会执行workerDone(this)进行一些清理操作：
void workerDone(Worker w) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
completedTaskCount += w.completedTasks;
workers.remove(w);
if (--poolSize == 0)
tryTerminate();
} finally {
mainLock.unlock();
}
}介绍完了Work的处理过程咱们再回到execute(Runnable command)方法，前面已经贴出源码了，这里再贴一份：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
if (runState == RUNNING && workQueue.offer(command)) {
if (runState != RUNNING || poolSize == 0)
ensureQueuedTaskHandled(command);
}
else if (!addIfUnderMaximumPoolSize(command))
reject(command); // is shutdown or saturated
}
}前面讲到当线程池的poolSize小于核心池corePoolSize时会去创建新线程来执行请求，然后如果poolSize超过了corePoolSize则会直接把请求Runnable添加进阻塞队列workQueue里，这里有两种情况：
1. 如果添加成功，则直接返回。前面介绍过，线程池的线程会执行完自己的请求后会从阻塞队列workQueue中取请求来执行。
2.如果添加失败（比如队列满了），则会通过addIfUnderMaximumPoolSize(command)创建新的线程来处理请求。
到这里可以解答第四个问题了：线程池的阻塞队列有什么用？阻塞队列有两个作用：第一是为了控制线程存活，通过workQueue的take和pull实现；第二是为了存放Runnable对象，以便线程池里空闲的线程处理。
下面继续介绍addIfUnderMaximumPoolSize(command)方法：
private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < maximumPoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}该方法和addIfUnderCorePoolSize(Runnable firstTask)方法类似，大致流程是如果线程池内创建的线程数小于最大线程数maximumPoolSize则创建新线程执行请求，否则返回false。
如果返回false，表示请求数量不能再被处理，此时会调用reject(command)来处理请求：
void reject(Runnable command) {
handler.rejectedExecution(command, this);
}可以看到，处理过程很简单，就直接调用handler来处理请求；这里的handler可以自定义（同样是通过构造函数传入），handler默认是使用AbortPolicy：
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException();
}AbortPolicy处理也是很简单粗暴，直接抛出非受查异常RejectedExecutionException。
到这里也可以解答第五个问题了：请求数量太多如何处理过多的请求？答案是通过handler处理的。
ThreadPoolExecutor 钩子
ThreadPoolExecutor设置确实十分精巧（作者就是大名鼎鼎的Doug Lea），上面介绍了它的一些实现细节；下面再来谈谈它的一些钩子。
默认情况下，线程池的线程只是在新任务到达时才创建和启动的；如果希望预先启动线程，可以使用方法 prestartCoreThread() 或 prestartAllCoreThreads() 。
prestartCoreThread()会创建并启动一个线程，prestartAllCoreThreads()会启动所以的corePoolSize个线程：
public boolean prestartCoreThread() {
return addIfUnderCorePoolSize(null);
}
public int prestartAllCoreThreads() {
int n = 0;
while (addIfUnderCorePoolSize(null))
++n;
return n;
}
private boolean addIfUnderCorePoolSize(Runnable firstTask) {
Thread t = null;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
if (poolSize < corePoolSize && runState == RUNNING)
t = addThread(firstTask);
} finally {
mainLock.unlock();
}
if (t == null)
return false;
t.start();
return true;
}另外还有两个常用的钩子方法：beforeExecute(java.lang.Thread, java.lang.Runnable) 和 afterExecute(java.lang.Runnable, java.lang.Throwable)。
protected void beforeExecute(Thread t, Runnable r) { }
protected void afterExecute(Runnable r, Throwable t) { }ThreadPoolExecutor内他们的默认实现为空方法。我们可以扩展它们，它们会在执行请求前后调用：
private void runTask(Runnable task) {
final ReentrantLock runLock = this.runLock;
runLock.lock();
try {
if (runState < STOP &&
Thread.interrupted() &&
runState >= STOP)
thread.interrupt();
boolean ran = false;
beforeExecute(thread, task);
try {
task.run();
ran = true;
afterExecute(task, null);
++completedTasks;
} catch (RuntimeException ex) {
if (!ran)
afterExecute(task, ex);
throw ex;
}
} finally {
runLock.unlock();
}
}正确使用ThreadPoolExecutor
我们通常使用 Executors 工厂方法来配置ThreadPoolExecutor，下面摘自ThreadPoolExecutor API：
来源：oschina
链接：https://my.oschina.net/u/1990220/blog/494698