源码分析
execute（提交）方法源码：
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
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);
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();
if (isRunning(c) ||
(runStateLessThan(c, STOP) && firstTask == null)) {
if (t.getState() != Thread.State.NEW)
throw new IllegalThreadStateException();
workers.add(w);
workerAdded = true;
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
addWorker方法
先看addWorker方法的第一部分，这个方法弄懂了，execute方法就非常好理解：
第一部分
先讲大致意思：
- 使用标志位并进入死循环
- 判断当前线程池状态、任务是否为空、阻塞队列是否为空
- 根据core判断当前线程量(区分核心线程、最大线程数量)是否达到最大限制
- 将当前线程数量+1，只有此方法成功才可退出死循环
- 判断当前状态，为true跳到标志位处，跳过本次循环，开启下次循环
首先一进来方法，就是两个死循环：
for(int c =ctl.get();;){
for(;;){
...
}
}
而唯一跳出死循环的办法就在第四步：
break retry;
可能很多人不理解为什么break要这么写，这其实就是标志位的写法，很多源码中都能看到
详情参考链接：java retry: 详解
所以break retry的含义就是 跳入到标志位处，且不再进入标志位下方的循环
continue retry：跳入到标志位处，跳过本次循环，进入下次循环
我们再来看看方法块中成员变量ctl及方法runstateAtleast()、compareAndIncrementWorkerCount()
成员变量ctl
源码中简单说明了ctl是一个成员变量，主要作用是记录线程池的生命周期状态和当前线程数，ctl是原子性的，作者通过巧妙的设计，将一个整形变量按二进制分为两部分，也就是说ctl中的成员变量value通过拆装箱可以表达两种含义（线程池的生命周期状态、当前线程数），想了解更深的可以参考链接（反正我是看不懂）：详解Java线程池的ctl(线程池控制状态)【源码分析】
线程池的声明周期状态：
- RUNNING：处于RUNNING状态的线程池能够接受新任务，以及对新添加的任务进行处理。
- SHUTDOWN：处于SHUTDOWN状态的线程池不可以接受新任务，但是可以对已添加的任务进行处理。
- STOP：处于STOP状态的线程池不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
- TIDYING：当所有的任务已终止，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
- TERMINATED：线程池彻底终止的状态。
拆装箱方法详解：线程池(二、ctl 的设计分析)
runStateAtLeast()
字面意思：线程池状态大于等于xx
来看这个方法使用：
runStateAtLeast(ctl.get(), SHUTDOWN))
private static boolean runStateAtLeast(int c, int s) {
return c >= s;
}
ctl.get()：就是获取ctl的成员变量value，之前也说到成员value是可以表达两种含义的(线程池的生命周期状态、当前线程数)，这里就有用到表达声明周期状态的用法。
SHUTDOWN是有初始化的，所以方法可以简单理解成：若当前ctl的生命周期状态>=SHUTDOWN，就证明当前线程池的生命周期状态是SHUTDOWN状态或者是其它状态，但绝不是RUNNING状态，线程池初始化的五种状态，值越大就代表当前线程池就越危险。
workerCountOf()
获取当前线程池的已有的线程数量。
compareAndIncrementWorkerCount©
/**
* Attempts to CAS-increment the workerCount field of ctl.
*/
private boolean compareAndIncrementWorkerCount(int expect) {
return ctl.compareAndSet(expect, expect + 1);
}
/**
* Atomically sets the value to {@code newValue}
* if the current value {@code == expectedValue},
* with memory effects as specified by {@link VarHandle#compareAndSet}.
*
* @param expectedValue the expected value
* @param newValue the new value
* @return {@code true} if successful. False return indicates that
* the actual value was not equal to the expected value.
*/
public final boolean compareAndSet(int expectedValue, int newValue) {
return U.compareAndSetInt(this, VALUE, expectedValue, newValue);
}
将当前ctl的value值加1，可以理解成当前线程数量+1
第二部分
- 新建线程，不区分核心线程、非核心线程，核心线程不会被删除，其实可以理解成保留核心线程大小的线程（保留maximumPoolSize个线程）
- 加锁，保证线程安全进行加锁。
- 判断当前线程池时状态，将新建的线程加入线程队列/集合（管理线程），线程队列在线程池创建时就创建，所以可以浅显的理解成线程池其实有两个队列，分别是阻塞队列（workQueue）-管理任务、线程队列（workers）-管理线程
- 解锁
- 执行任务，注意这里是
直接执行任务了，并没有交给阻塞队列。 - 回退，将刚加入的线程取消
Worker
Woker就是线程池的内部类，构造方法就是调用线程工厂新建线程
/**
* Creates with given first task and thread from ThreadFactory.
* @param firstTask the first task (null if none)
*/
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
/**
* Returns the thread factory used to create new threads.
*
* @return the current thread factory
* @see #setThreadFactory(ThreadFactory)
*/
public ThreadFactory getThreadFactory() {
// 返回当前线程池的线程工厂
return threadFactory;
}
execute方法
- 判断当前线程数量是否小于核心线程个数，小于则直接新增线程并直接执行任务(注意是直接，没有放入到阻塞队列中)，
- 大于则判断当前线程池状态是否为RUNNING，并将任务当前加入阻塞队列中
- 加入阻塞队列成功后 需要判断当前线程池状态是否正常，不正常则回退阻塞队列（remove(command)）并执行拒绝策略（reject(command)）
- 加入阻塞队列成功后 需要判断当前线程数量是否为0(当核心线程数为0时，会导致任务无法被线程执行)，为true则新增一个线程但并没有执行任务，因为任务已经添加进入阻塞队列了，且firstTask为null，所以addWorker方法执行的任务是空的
- 加入阻塞队列失败后 创建一个新线程并执行马上执行任务，若是创建线程失败（可能的原因：线程数量已达到最大限制、线程池状态异常）则采用拒绝策略
这里可能大部分不会理解，为什么在第二步加入阻塞队列之后还需要再判断有没有线程、线程池状态，这里因为在创建线程池的时候，核心线程大小个数可能会被设置成0，若是设置为0，则可以跳过第一步的判断，若是没有第四步则会导致任务都会进入阻塞队列，但是却没有线程执行任务。
总结
- 先查看当前线程池的线程数量是否小于
核心线程数大小，小于则新建线程并直接执行任务 - 大于则放入阻塞队列中，加入阻塞后，任务在未来某个时间点被一个空闲的线程取出执行，但是在加入到阻塞队列后，还会检查当前是否有线程存在(因为当核心线程数量设置为0的时候，程序也会执行到一步，但是会出现一个情况：阻塞队列里的任务无法被提取执行，因为当前线程池并没有线程，所有这里会创建一个线程)
- 当阻塞队列也满了，则会新建线程并立即执行任务
- 若线程数量也达到最大限制就会执行对应的拒绝策略
