前言
本文主要是结合源码去线程池执行任务的过程，基于JDK 11，整个过程基本与JDK 8相同。
个人水平有限，文中若有表达有误的，欢迎大伙留言指出，谢谢了！
一、线程池简介
1.1 使用线程池的优点
1）通过复用已创建的线程，降低资源的消耗（线程的创建/销毁是要消耗资源的）、提高响应速度；
2）管理线程的个数，线程的个数在初始化线程池的时候指定；
3）统一管理线程，比如停止，stop()方法；
1.2 线程池执行任务过程
线程池执行任务的过程如下图所示，主要分为以下4步，其中参数的含义会在后面详细讲解：
1）判断工作的线程是否小于核心线程数据（workerCountOf(c) < corePoolSize），若小于则会新建一个线程去执行任务，这一步仅仅的是根据线程个数决定；
2）若核心线程池满了，就会判断线程池的状态，若是running状态，则尝试加入任务队列，若加入成功后还会做一些事情，后面详细说；
3）若任务队列满了，则加入失败，此时会判断整个线程池线程是否满，若没有则创建非核心线程执行任务；
4）若线程池满了，则根据拒绝测试处理无法执行的任务；
整体过程如下图：
二、ThreadPoolExecutor类解析
2.1 ThreadPoolExecutor的构造函数
ThreadPoolExecutor类一共提供了4个构造函数，涉及5~7个参数，下面就5个必备参数的构造函数进行说明：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
1）corePoolSize ：初始化核心线程池中线程个数的大小；
2）maxmumPoolSize：线程池中线程大小；
3）keepAliveTime：非核心线程的超时时长；
非核心线程空闲时常大于该值就会被终止。
4）unit ：keepAliveTime的单位，类型可以参见TimeUnit类；
5）BlockingQueue workQueue：阻塞队列，维护等待执行的任务；
2.2 私有类Worker
在ThreadPoolExecutor类中有两个集合类型比较重要，一个是用于放置等待任务的workQueue，其类型是阻塞对列；一个是用于用于存放工作线程的works，其是Set类型，其中存放的类型是Worker。
进一步简化线程池执行过程，可以理解为works中的工作线程不停的去阻塞对列中取任务，执行结束，线程重新加入大works中。
为此，有必要简单了解一下Work类型的组成。
private final class Worker
extends AbstractQueuedSynchronizer
implements Runnable
{
/** Thread this worker is running in. Null if factory fails. */
//工作线程，由线程的工厂类初始化
final Thread thread;
/** Initial task to run. Possibly null. */
Runnable firstTask;
/** Per-thread task counter */
volatile long completedTasks;
//不可重入的锁
protected boolean tryAcquire(int unused) {
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
} .......
}
Worker类继承于队列同步器（AbstractQueueSynchronizer），队列同步器是采取锁或其他同步组件的基础框架，其主要结构是自旋获取锁的同步队列和等待唤醒的等待队列，其方法因此可以分为两类：对state改变的方法 和 入、出队列的方法，即获取获取锁的资格的变化（可能描述的不准确）。关于队列同步器后续博客会详细分析，此处不展开讨论。
Work类中通过CAS设置状态失败后直接返回false，而不是判断当前线程是否已获取锁来实现不可重入的锁，源码注释中解释这样做的原因是因为避免work tash重新获取到控制线程池全局的方法，如setCorePoolSize。
2.3 拒绝策略类
ThreadPoolExecutor的拒绝策略类是以私有类的方式实现的，有四种策略：
1）AbortPolicy：丢弃任务并抛出RejectedExecutionException异常（默认拒绝处理策略）。
2）DiscardPolicy：抛弃新来的任务，但是不抛出异常。
3）DiscardOldestPolicy：抛弃等待队列头部（最旧的）的任务，然后重新尝试执行程序（失败则会重复此过程）。
4）CallerRunsPolicy：由调用线程处理该任务。
其代码相对简单，可以参考源码。
三、任务执行过程分析
3.1 execute(Runnable)方法
execute(Runnable)方法的整体过程如上文1.2所述，其实现方式如下：
public void execute(Runnable command) {
//执行的任务为空，直接抛出异常
if (command == null)
throw new NullPointerException();
//ctl是ThreadPoolExecutor中很关键的一个AtomicInteger,主线程池的控制状态
int c = ctl.get();
//1、判断是否小于核心线程池的大小，若是则直接尝试新建一个work线程
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
//2、大于核心线程池的大小或新建work失败（如创建thread失败），会先判断线程池是否是running状态，若是则加入阻塞对列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
//重新验证线程池是否为running，若否，则尝试从对列中删除，成功后执行拒绝策略
if (! isRunning(recheck) && remove(command))
reject(command);
//若线程池的状态为shutdown则，尝试去执行完阻塞对列中的任务
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
//3、新建非核心线程去执行任务，若失败，则采取拒绝策略
else if (!addWorker(command, false))
reject(command);
}3.2 addWorker(Runnable,boole)方法
execute(Runnable)方法中，新建（非）核心线程执行任务主要是通过addWorker方法实现的，其执行过程如下：
private boolean addWorker(Runnable firstTask, boolean core) {
//此处反复检查线程池的状态以及工作线程是否超过给定的值
retry:
for (int c = ctl.get();;) {
// Check if queue empty only if necessary.
if (runStateAtLeast(c, SHUTDOWN)
&& (runStateAtLeast(c, STOP)
|| firstTask != null
|| workQueue.isEmpty()))
return false;
for (;;) {
//核心和非核心线程的区别
if (workerCountOf(c)
>= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateAtLeast(c, SHUTDOWN))
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);
//通过工厂方法初始化，可能失败，即可能为null
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 c = ctl.get();
//线程池处于running状态
//或shutdown状态但无需要执行的task，个人理解为用于去阻塞队列中取任务执行
if (isRunning(c) ||
(runStateLessThan(c, STOP) && 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;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
//执行任务，这里会执行thread的firstTask获取阻塞对列中取任务
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
//开始失败，则会从workers中删除新建的work,work数量减1，尝试关闭线程池，这些过程会获取全局锁
addWorkerFailed(w);
}
return workerStarted;
}3.3 runWorker(this) 方法
在3.2 中当新建的worker线程加入在workers中成功后，就会启动对应任务，其调用的是Worker类中的run()方法，即调用runWorker(this)方法，其过程如下：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
//while()循环中，前者是新建线程执行firstTask，对应线程个数小于核心线程和阻塞队列满的情况，
//getTask()则是从阻塞对列中取任务执行
while (task != null || (task = getTask()) != null) {
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
//仅线程池状态为stop时，线程响应中断，这里也就解释了调用shutdown时，正在工作的线程会继续工作
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
try {
//执行任务
task.run();
afterExecute(task, null);
} catch (Throwable ex) {
afterExecute(task, ex);
throw ex;
}
} finally {
task = null;
//完成的个数+1
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
//处理后续工作
processWorkerExit(w, completedAbruptly);
}
}3.4 processWorkerExit（Worker,boole）方法
当任务执行结果后，在满足一定条件下会新增一个worker线程，代码如下：
private void processWorkerExit(Worker w, boolean completedAbruptly) {
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();
if (runStateLessThan(c, STOP)) {
//线程不是中断，会维持最小的个数
if (!completedAbruptly) {
int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
if (min == 0 && ! workQueue.isEmpty())
min = 1;
if (workerCountOf(c) >= min)
return; // replacement not needed
}
//执行完任务后，线程重新加入workers中
addWorker(null, false);
}
}至此，线程池执行任务的过程分析结束，其他方法的实现过程可以参考源码。
Ref：
[1]http://concurrent.redspider.group/article/03/12.html
[2]《Java并发编程的艺术》