前言
本文主要是结合源码去线程池执行任务的过程，基于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并发编程的艺术》