线程池用来执行任务的，是通过创建线程来执行任务的，这个线程什么时候被创建呢，是在内部类Worker的构造函数中才会被创建。这个线程的作用就是不停的从阻塞队列中获取任务然后执行。
问：线程池是如何创建线程的？
答：在Worker类的构造函数里。
问：Worker什么时候会被构造？
答：是在方法addWorker()中。
问：线程池的线程启动之后用来做什么？
答：会调用runWorker()方法。
线程池的状态机
- RUNNING：运行状态，接受新的任务，处理等待队列中的任务
- SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务
- STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程
- TIDYING：所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()
- TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个
RUNNING 定义为 -1，SHUTDOWN 定义为 0，其他的都比 0 大，所以等于 0 的时候不能提交任务，大于 0 的话，连正在执行的任务也需要中断。
RUNNING < SHUTDOWN < STOP < TIDYING < TERMINATED
Worker
Worker是ThreadPoolExecutor的内部类，可以简单的理解为Worker就是工作线程，让我看看Worker的类结构：
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
{
// 这个是真正的线程，这个Worker对象在thread这个线程中运行的，也就是说这个thread就是运行在线程池中的线程
final Thread thread;
// Worker对象执行的第一个任务，如果为null，他会不停从任务队列（BlockingQueue）中取任务（getTask 方法）
Runnable firstTask;
// 用于存放此线程完全的任务数，注意了，这里用了 volatile，保证可见性
volatile long completedTasks;
// Worker 只有这一个构造方法，传入 firstTask，也可以传 null
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
// 调用 ThreadFactory 来创建一个新的线程，传入this
this.thread = getThreadFactory().newThread(this);
}
// 这里调用了外部类的 runWorker 方法
// 这thread线程中执行 run 方法
public void run() {
runWorker(this);
}
...// 其他几个方法没什么好看的，就是用 AQS 操作，来获取这个线程的执行权，用了独占锁
}Worker类的作用根据上面的属性说明应该能够理解了。Worker构造函数接收一个task属性，这个Worker启动之后会先执行这个task，然后再去阻塞队列中获取任务执行，如果获取不到任务了，这个Worker就会执行完了，这个线程也就结束了。
进入正题，ThreadPoolExecutor#execute(Runnable command)
我们看下ThreadPoolExecutor的最重要的方法execute(Runnable command)，它是如何处理新任务：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
// 前面说的那个表示 “线程池状态” 和 “线程数” 的整数
int c = ctl.get();
// 如果当前线程数少于核心线程数，那么直接添加一个 worker 来执行新任务，
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true)) {
// 表示添加成功了线程池已经接受了这个新任务，至于执行的结果，到时候会包装到 FutureTask 中
return;
}
// 创建Worker失败，有可能是线程池状态被改变了，这里重新获取
c = ctl.get();
}
// 执行到这里说明有两种情况：
// 1、当前线程数大于等于核心线程数；
// 2、刚刚 addWorker 失败了
if (isRunning(c) && workQueue.offer(command)) {
// 正常情况下，只要队列未满，不会创建新线程
// 如果线程池处于 RUNNING 状态，并且任务添加到阻塞队列成功（表示阻塞队列未满）
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command)) {
// 重新检查下，如果线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，并且执行拒绝策略
reject(command);
}
else if (workerCountOf(recheck) == 0) {
// 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程，怕线程池为空就没人处理任务了
addWorker(null, false);
}
}
// 如果 workQueue 队列满了，那么进入到这个分支
// 以 maximumPoolSize 为界创建新的 worker，
// 如果失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
else {
// 这里有两种情况：
// 1、线程池状态不是RUNNING，不支持新任务，reject
// 2、线程状态为RUNNING，但是阻塞队列满了（workQueue.offer(command)返回false表示满了）,就用最大线程数为界限创建
if (!addWorker(command, false)) {
// 两种情况会拒绝：
// 1、线程池状态不是RUNNING，拒绝新任务
// 2、线程状态为RUNNING，但是超过最大线程数了，拒绝新任务
reject(command);
}
}
}从源码中我们可以看到：线程池在RUNNING状态时
1、线程数量小于核心线程数，就创建新线程处理新任务。代码中得到印证
2、线程数量大于等于核心线程数，就尝试把新任务放入阻塞队列。代码中得到印证
3、阻塞队列满了之后，线程数量小于最大线程数，就创建新线程处理任务。代码中得到印证
execute(Runnable command)方法中只调用了创建了Worker，那Worker对象究竟是怎么执行任务的呢，首先我们得先看下Worker是如何创建的，线程是何时运行的，我们先看下addWorker(Runnable firstTask, boolean core)这个方法是如何创建线程的
// 第一个参数表示交个这个线程的第一个执行的任务，可以为null，如果不是null，表示这是个新任务
// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线，也就说创建这个线程的时候，
// 如果线程池中的线程总数已经达到 corePoolSize，那么不能创建线程
// 如果是 false，代表使用最大线程数 maximumPoolSize 作为界线
// 在调用者所在的线程中，向线程池中创建线程
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c); // rs是当前线程池状态
// 只有两种情况，才能往下走，否则直接不创建新的线程
// 1、线程池状态为 RUNNING
// 2、线程池状态为 SHUTDOWN ，并且不是新任务（firstTask == null表示不是新任务），并且阻塞队列不为空（表示队列里还有任务）
// 结合线程池状态说明下：
// 1、当线程池处于 SHUTDOWN 的时候，不允许提交任务，但是可以创建线程去处理队列中已有的任务
// 多说一句：如果线程池处于 SHUTDOWN，但是 firstTask 为 null，且 workQueue 非空，那么是允许创建 worker 的
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操作设置线程数量+1，如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务了
if (compareAndIncrementWorkerCount(c))
break retry;
// 由于有并发，重新再读取一下 ctl
c = ctl.get();
// 可是如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池，那么需要回到外层的for循环
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
// CAS操作失败的话，说明有其他线程也在尝试往线程池中创建线程，重新内部循环
}
}
/*
* 到这里，我们认为在当前这个时刻，可以开始创建线程来执行任务了，
*/
// worker 是否已经启动
boolean workerStarted = false;
// 是否已将这个 worker 添加到 workers 这个 HashSet 中
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 c = ctl.get();
int rs = runStateOf(c);
// 小于 SHUTTDOWN 那就是 RUNNING，这个自不必说，是最正常的情况
// 如果等于 SHUTDOWN，不接受新的任务（firstTask == null表示不是新任务），但是会继续执行等待队列中的任务
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
// worker 里面的 thread 可不能是已经启动的
if (t.isAlive())
throw new IllegalThreadStateException();
// 加到 workers 这个 HashSet 中
workers.add(w);
int s = workers.size();
// largestPoolSize 用于记录 workers 中的个数的最大值，
// 因为 workers 是不断增加减少的，通过这个值可以知道线程池的大小曾经达到的最大值
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
// 添加成功的话，启动这个线程
if (workerAdded) {
// 启动线程去执行worker
t.start();
workerStarted = true;
}
}
} finally {
// 如果线程没有启动，需要做一些清理工作，如前面 workCount 加了 1，将其减掉
if (! workerStarted)
addWorkerFailed(w);
}
// 返回线程是否启动成功
return workerStarted;
}我们已经看到线程启动了，那这个线程启动做了什么事情呢，我们看下runWorker(Worker w)这个方法。
// Worker 类的 run() 方法
public void run() {
runWorker(this);
}
// 此方法由 worker 线程启动后调用，这里用一个 while 循环来不断地从等待队列中获取任务并执行
// 前面说了，worker 在初始化的时候，可以指定 firstTask，那么第一个任务也就可以不需要从队列中获取
final void runWorker(Worker w) {
//
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
// 循环调用 getTask 获取任务
while (task != null || (task = getTask()) != null) {
w.lock();
// 如果线程池状态大于等于 STOP，那么意味着该线程也要中断
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
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) {
// 这里不允许抛出 Throwable，所以转换为 Error
thrown = x; throw new Error(x);
} finally {
// 也是一个钩子方法，将 task 和异常作为参数，留给需要的子类实现
afterExecute(task, thrown);
}
} finally {
// 置空 task，准备 getTask 获取下一个任务
task = null;
// 累加完成的任务数
w.completedTasks++;
// 释放掉 worker 的独占锁
w.unlock();
}
}
completedAbruptly = false;
} finally {Exit 中处理
// 限于篇幅，我不准备分析这个方法了，感兴趣的读者请自行分析源码
processWorkerExit(w, completedAbruptly);
}
}让我们继续分析，Worker是如何从阻塞队列中获取任务的
// 方法返回null，线程数会减一，也表示Worker的线程就会执行结束而关闭了
private Runnable getTask() {
boolean timedOut = false; // Did the last poll() time out?
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
// 两种可能会减少线程，返回null
// 1. 线程池状态为 SHUTDOWN ，而且阻塞队列为空，任务执行完了
// 2. 线程池状态 >= STOP，不管阻塞队列是否还有任务，直接返回null
decrementWorkerCount();
return null;
}
int wc = workerCountOf(c);
// Are workers subject to culling?
// timed=true，表示需要关闭空闲的线程
// allowCoreThreadTimeOut表示是否允许核心线程数空闲时候关闭它
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))
&& (wc > 1 || workQueue.isEmpty())) {
// 这里有两种情况会减少线程，返回null：
// 1、线程数大于最大线程数（比如手动设置，把最大线程数设置小了）
// 2、线程数小于等于最大线程数，但是在keepAliveTime时间内没有获取到任务，表示空闲
if (compareAndDecrementWorkerCount(c))
return null;
continue;
}
try {
Runnable r = timed ?
workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
workQueue.take();
if (r != null)
return r;
// r == null，只有workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)超时了才会返回
timedOut = true;
} catch (InterruptedException retry) {
timedOut = false;
}
}
}线程池提交任务的流程简述
写到这里，我才能正在理解下面这张图，这是在正常情况下，也就是RUNNING状态下，任务提交的流程。
线程关闭
shutdown，修改状态为SHUTDOWN，拒绝新任务，会继续执行阻塞队列中的任务，中断闲置的Worker。
shutdownNow，修改状态为STOP，拒绝新任务，中断所有Worker，会影响阻塞队列中的任务。
shutdown
public void shutdown() {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); // 关闭的时候需要加锁，防止并发
try {
checkShutdownAccess(); // 检查关闭线程池的权限
advanceRunState(SHUTDOWN); // 把线程池状态更新到SHUTDOWN
interruptIdleWorkers(); // 中断闲置的Worker
onShutdown(); // 钩子方法，默认不处理。ScheduledThreadPoolExecutor会做一些处理
} finally {
mainLock.unlock(); // 解锁
}
tryTerminate(); // 尝试结束线程池，上面已经分析过了
}// shutdownNow方法会有返回值的，返回的是一个任务列表，而shutdown方法没有返回值
public List<Runnable> shutdownNow() {
List<Runnable> tasks;
final ReentrantLock mainLock = this.mainLock;
mainLock.lock(); // shutdownNow操作也需要加锁，防止并发
try {
checkShutdownAccess(); // 检查关闭线程池的权限
advanceRunState(STOP); // 把线程池状态更新到STOP
interruptWorkers(); // 中断Worker的运行
tasks = drainQueue();
} finally {
mainLock.unlock(); // 解锁
}
tryTerminate(); // 尝试结束线程池，上面已经分析过了
return tasks;
}闲置Worker是这样解释的：Worker运行的时候会去阻塞队列拿数据(getTask方法)，拿的时候如果没有设置超时时间，那么会一直阻塞等待阻塞队列进数据，这样的Worker就被称为闲置Worker。由于Worker也是一个AQS，在runWorker方法里会有一对lock和unlock操作，这对lock操作是为了确保Worker不是一个闲置Worker。
附录：
https://juejin.im/entry/59b232ee6fb9a0248d25139a
https://www.cnblogs.com/warehouse/p/10720781.html
https://fangjian0423.github.io/2016/03/22/java-threadpool-analysis/
来源：oschina
链接：https://my.oschina.net/cregu/blog/3178816