概述

本文尝试回答以下几个问题：
1、核心线程池是如何保持住的？
2、当没有任务时，超过核心线程数的线程是如何回收的？
3、线程队列为什么必须是BlockingQueue，普通队列行不行？

背景知识

以下是一些背景知识，方便后面分析问题，如果明白可以跳过，否则建议重温下。

线程参数

1. corePoolSize：核心线程数。
2. maximumPoolSize：最大线程数。
3. keepAliveTime：空闲线程存活时间。
4. TimeUnit：时间单位。
5. BlockingQueue：线程池任务队列。
6. ThreadFactory：创建线程的工厂。
7. RejectedExecutionHandler：拒绝策略，包括Abort、callRuns，discard，discardOld.

线程池结构

以ThreadPoolExecutor为例，它的结构如下所示：

最重要的两个类就是我们的ThreadPoolExecutor和Worker，其中ThreadPoolExecutor就是线程池本池了，Worker是对Thread的一个简单封装，它实现了Runnable接口，我们可以把它当作线程Thread本身。我们需要知道这些字段的含义是怎样的：

提交任务做了什么？

创建线程池没有任何有价值的东西，就是对ThreadPoolExecutor的属性进行赋值，例如我们刚才提到的那几个重要的属性，所以我们从execute提交任务开始探索内部。
![在这里插入图片描述](https://img-blog.csdnimg.cn/b8b29d220ece460798819a451e1a34b4.png
当我们创建了线程池，调用execute提交一个Runnable任务，执行流程如下所示：

执行流程
1、任务到来时，看CORE线程数有没有满，如果没有满则新创建线程处理。
2、如果core线程数量满了，则放入队列中。
3、如果队列也满了，则看看线程数量是否达到了maxPoolSize值，如果没有则创建新线程处理。
4、如果已经达到了maxPoolSize的值，则根据拒绝策略处理任务。
所以当有人问execute做了什么时候，可以回答这个执行流程，这是面试时经常问的问题。知道这个流程后，我们再来看下代码是怎么写的(按照惯例，省略了无关代码)：

public void execute(Runnable command) {int c = ctl.get();if (workerCountOf(c) < corePoolSize) { // 当线程数量小于核心线程数时，创建新的线程，请注意这里给了command，也就是我们自定义的Runnable任务，后面会再次提到它！if (addWorker(command, true))return;c = ctl.get();}if (isRunning(c) && workQueue.offer(command)) { // 上面没有走到，说明核心线程数量已经满了，则尝试将任务添加到任务队列中，也就是这里的workQueueint recheck = ctl.get();if (! isRunning(recheck) && remove(command))reject(command);else if (workerCountOf(recheck) == 0)addWorker(null, false);}else if (!addWorker(command, false)) // 添加队列失败，说明队列满了。尝试依赖maxPoolSize创建线程，如果失败则根据拒绝策略处理任务reject(command);}

是不清晰多了？不过我们需要继续深挖，看看addWorker()干了什么？第二个boolean参数又是干嘛用的？

private boolean addWorker(Runnable firstTask, boolean core) {retry:for (;;) { // for循环主要通过cas更新线程worker数量int c = ctl.get(); // 拿到线程数量 for (;;) {int wc = workerCountOf(c);if (wc >= CAPACITY ||wc >= (core " />: maximumPoolSize)) // 因为核心线程数和最大线程数控制着线程的上限，这个boolean参数就是检查是不是还能创建线程。return false;if (compareAndIncrementWorkerCount(c))// 线程数量+1break retry;c = ctl.get();// Re-read ctlif (runStateOf(c) != rs)continue retry;// else CAS failed due to workerCount change; retry inner loop}}// 创建workerboolean workerStarted = false;boolean workerAdded = false;Worker w = null;try {w = new Worker(firstTask); // 看清楚了！这里就是真正的创建线程了，并把任务作为参数传递进去final Thread t = w.thread;if (t != null) {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {int rs = runStateOf(ctl.get());if (rs < SHUTDOWN ||(rs == SHUTDOWN && firstTask == null)) {if (t.isAlive()) // precheck that t is startablethrow new IllegalThreadStateException();workers.add(w); // 把worker添加到worker集合中int s = workers.size();if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;}} finally {mainLock.unlock();}if (workerAdded) {t.start(); // 启动线程workerStarted = true;}}} finally {if (! workerStarted)addWorkerFailed(w);}return workerStarted;}

我们用流程图表示下：

从上面的流程图我们可以知道，addworker做了3件事情：
1、更新worker数量
2、创建worker对象，其中包括创建Thread对象并设置好runnable任务
3、启动线程
第二个boolean参数，实际上就是控制创建worker对线程数量做检查时，需要和什么对比，是和核心线程数量配置对比还是和最大线程数量配置做比对。

worker启动干了什么？

worker实现了Rnnable接口，所以线程启动后，会调用run方法：

我们需要看看runWorker()做了什么：

final void runWorker(Worker w) {Thread wt = Thread.currentThread();// 获取当前线程Runnable task = w.firstTask; // 需要执行的任务w.firstTask = null;w.unlock(); // allow interruptsboolean completedAbruptly = true;try {while (task != null || (task = getTask()) != null) { // 这里非常重要！！！w.lock();try {beforeExecute(wt, task);Throwable thrown = null;try {task.run(); // 执行任务} catch (RuntimeException x) {thrown = x; throw x;} catch (Error x) {thrown = x; throw x;} catch (Throwable x) {thrown = x; throw new Error(x);} finally {afterExecute(task, thrown);}} finally {task = null;w.completedTasks++;w.unlock();}}completedAbruptly = false;} finally {processWorkerExit(w, completedAbruptly);}}

实际上这里最关键的就两步：
1、获取任务
2、执行任务

获取任务是从worker中拿到的，我们注意到有一行非常重要的判断：

什么情况下task为空，什么情况下需要调用getTask()去获取任务？
请回想一下我们线程池execute的执行流程，其中1，2步骤就曾经说过：
1、任务到来时，看CORE线程数有没有满，如果没有满则新创建线程处理。这个时候创建worker的调用是：

addWorker(command, true)

这就保证我们运行获取任务时是非空的。
2、如果core线程数量满了，则放入队列中。这个时候调用的是：

workQueue.offer(command)

这就保证我们getTask（）时能取到任务！

现在重点来了，我们今天要回答的问题就和这个getTask有莫大的关系！在理解下面的代码前，我们先假设corePoolSize < 线程数量 < MaxPoolSize 并且 队列里面已经没有任务了，也就是没有任务的时候，有一些线程需要被回收。

private Runnable getTask() {boolean timedOut = false; // 上一次通过poll从任务队列获取任务是否超时，如果超时说明任务队列没有任务了for (;;) {// 这是一个循环int c = ctl.get();int rs = runStateOf(c);int wc = workerCountOf(c); // 获取线程数量// Are workers subject to culling" />boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; // 我们先撇开allowCoreThreadTimeOut这个参数，当线程数量大于核心线程数配置，说明在没有任务的时候可以对一些剩余的线程去做回收操作。if ((wc > maximumPoolSize || (timed && timedOut))&& (wc > 1 || workQueue.isEmpty())) {// timed=true,timeOut=true，队列也空了，对线程数量-1if (compareAndDecrementWorkerCount(c))return null;continue;}try {Runnable r = timed ?workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take();// 这里就是重点了！当线程数量>核心线程数时，走的是poll代码块if (r != null)return r;timedOut = true; // 因为take会阻塞线程直到有任务到达，所以这里只能是poll没有拿到任务，也就是任务队列是空，然后返回循环去做线程-1} catch (InterruptedException retry) {timedOut = false;}}}

如果是核心线程获取任务（核心非核心没有标记区别，这里是做个假设），因为timed为false，会走到workQueue.take()方法，如果任务队列为空，线程会被阻塞。非核心线程获取任务会走到workQueue.poll()，尝试在超时时间内获取任务，然后返回。

到此为止我们可以回答“核心线程池是如何保持住的？”答案就是通过workQueue.take()方法对线程进行阻塞，让我们线程保持住不被数量-1而回收掉。
然后我们可以回答“线程队列为什么必须是BlockingQueue，普通队列行不行？”答案就是不行，我们需要通过阻塞队列对线程进行阻塞，保证线程不会被回收掉。关于BlockingQueue怎么实现阻塞的，建议温习下java阻塞队列原理。这也是面试经常会被问到的。
我们知道需要回收条件触发时（当线程数量大于核心线程数配置，任务队列中没有任务），线程数量会被 – 1，那么回收具体时怎么操作的呢？
回到我们的任务执行方法runWorker中，最后有一步processWorkerExit调用：

private void processWorkerExit(Worker w, boolean completedAbruptly) {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {completedTaskCount += w.completedTasks;workers.remove(w); // 把线程从线程集合中删除，通过jvm回收} finally {mainLock.unlock();}int c = ctl.get();if (runStateLessThan(c, STOP)) {if (!completedAbruptly) { // 线程异常时，completedAbruptly会被设置为trueint min = allowCoreThreadTimeOut " />0 : corePoolSize;if (min == 0 && ! workQueue.isEmpty())min = 1;if (workerCountOf(c) >= min) // 线程数本身就大于核心线程数量，不用补偿return; // replacement not needed}addWorker(null, false); // 线程异常后的一种补偿，重新创建一个线程替换异常线程}}

到此我们可以回答“当没有任务时，超过核心线程数的线程是如何回收的？”，答案是先将线程数-1，然后将woker从worker列表中删除，通过jvm回收。

总结

通过对线程池的学习，我们知道了线程池的执行流程：
1、任务到来时，看CORE线程数有没有满，如果没有满则新创建线程处理。
2、如果core线程数量满了，则放入队列中。
3、如果队列也满了，则看看线程数量是否达到了maxPoolSize值，如果没有则创建新线程处理。
4、如果已经达到了maxPoolSize的值，则根据拒绝策略处理任务。

然后我们可以回答这些问题：
1、核心线程池是如何保持住的？

通过workQueue.take()方法对线程进行阻塞，让我们线程保持住不被数量-1而回收掉

2、当没有任务时，超过核心线程数的线程是如何回收的？

先将线程数-1，然后将woker从worker列表中删除，通过jvm回收

3、线程队列为什么必须是BlockingQueue，普通队列行不行？

不行，我们需要通过阻塞队列对线程进行阻塞，保证线程不会被回收掉。

如果我们看的仔细，我们实际上还可以回答诸如下面的问题：
1、如果我想在任务执行前后做一些诸如打日志看耗时的操作，有办法吗？
2、核心线程池的线程永远都是这些线程吗？会不会变化？
3、如果线程池运行中动态设置了corePoolSize > 原始corePoolSize，现有线程数量小于新的corePoolSize，任务队列中还有任务，会自动创建线程吗？是怎么做的？
4、keepAliveTime是空闲线程超时时间，是有定时任务回收空闲线程吗？
5、为什么获取任务时，workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)写死了NANOSECONDS，明明创建线程的时候是可以指定时间单位的？

大家可以尝试自行回答下，答案进行了base64编码，可在base64解码解码后查看。

MeOAgeWmguaenOaIkeaDs+WcqOS7u+WKoeaJp+ihjOWJjeWQjuWBmuS4gOS6m+ivuOWmguaJk+aXpeW/l+eci+iAl+aXtueahOaTjeS9nO+8jOacieWKnuazleWQl++8nwoKPiDmnInlip7ms5XjgILnur/nqIvmiafooYznmoTml7blgJnkvJrmnInliY3nva7lkI7nva7mianlsZXngrnvvIzlj6/ku6XlnKjlrZDnsbvkuK3ov5vooYzlrp7njrDjgIIKCjLjgIHmoLjlv4Pnur/nqIvmsaDnmoTnur/nqIvmsLjov5zpg73mmK/ov5nkupvnur/nqIvlkJfvvJ/kvJrkuI3kvJrlj5jljJbvvJ8KCj4g5LiN5piv44CC5b2T57q/56iL5omn6KGM5byC5bi45pe277yM5Lya5pyJ6KGl5YG/5py65Yi277yM5Yib5bu65paw55qE57q/56iL5pu/5o2i44CCCgoz44CB5aaC5p6c57q/56iL5rGg6L+Q6KGM5Lit5Yqo5oCB6K6+572u5LqGY29yZVBvb2xTaXplID4g5Y6f5aeLY29yZVBvb2xTaXpl77yM546w5pyJ57q/56iL5pWw6YeP5bCP5LqO5paw55qEY29yZVBvb2xTaXpl77yM5Lu75Yqh6Zif5YiX5Lit6L+Y5pyJ5Lu75Yqh77yM5Lya6Ieq5Yqo5Yib5bu657q/56iL5ZCX77yf5piv5oCO5LmI5YGa55qE77yfCgo+IOS8muOAguS5n+aYr+mAmui/h2FkZFdvcmtlcuWIm+W7uuOAggoKNOOAgWtlZXBBbGl2ZVRpbWXmmK/nqbrpl7Lnur/nqIvotoXml7bml7bpl7TvvIzmmK/mnInlrprml7bku7vliqHlm57mlLbnqbrpl7Lnur/nqIvlkJfvvJ8KCj4g5rKh5pyJ44CC5LuO5Lu75Yqh6Zif5YiX6I635Y+W5Lu75Yqh5pe277yM5pyJ6LaF5pe25pe26Ze077yM5bCx5piv6L+Z5Liqa2VlcEFsaXZlVGltZe+8jOi2heaXtuayoeacieiOt+WPluWIsOS7u+WKoe+8jOS8mui/lOWbnm51bGzvvIznhLblkI7lvIDlp4vlm57mlLbnur/nqIvjgIIKCjXjgIHkuLrku4DkuYjojrflj5bku7vliqHml7bvvIx3b3JrUXVldWUucG9sbChrZWVwQWxpdmVUaW1lLCBUaW1lVW5pdC5OQU5PU0VDT05EUynlhpnmrbvkuoZOQU5PU0VDT05EU++8jOaYjuaYjuWIm+W7uue6v+eoi+eahOaXtuWAmeaYr+WPr+S7peaMh+WumuaXtumXtOWNleS9jeeahO+8nwoKPiDliJvlu7rnur/nqIvmsaDnmoTml7blgJnvvIzpgJrov4d1bml0LnRvTmFub3Moa2VlcEFsaXZlVGltZSnovazmjaLlpb3kuobml7bpl7TljZXkvY3jgII=