线程池是JDK中设计很巧妙的一部分，通过线程池相关的问题大致就可以了解到候选人对Java基础的掌握程度，经典的问题如：
线程池提交任务执行的过程？
看似简单，但是能真的把源码说清楚的人少之又少，这里我们一起探索下这个问题的一小部分。比如说我们知道在提交执行任务时，会首先创建核心线程。
具体执行过程参考早先的博客：https://www.jianshu.com/p/4e7af21c0a62
那么创建核心线程的过程是什么样的呢？
核心线程创建过程
基础数据结构
线程池中预定义了一些常量，这些常量要先进行了解，才知道线程池的方法到底执行的结果是什么，为什么会有这种结果。
线程池的状态，我标记这么多0，方便后面知道线程池池内部的计算规则
// 32 - 3 = 29
private static final int COUNT_BITS = Integer.SIZE - 3;
// 2^29-1 = 536870911
// 11111111111111111111111111111，总共是29个1
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// runState is stored in the high-order bits
// -1^29 = -536870912 = -(1 << 29)
// 11100000000000000000000000000000 , 29个0，计算机中负数的二进制表示方式。
// 参考：https://jingyan.baidu.com/article/29697b9106eb52ab21de3c7a.html
private static final int RUNNING = -1 << COUNT_BITS;
private static final int SHUTDOWN = 0 << COUNT_BITS;
// 1^29 = 536870912
// 100000000000000000000000000000 ，总共29个0
private static final int STOP = 1 << COUNT_BITS;
// 2^29 = 2^30 = 1073741824
// 1000000000000000000000000000000 ，总共30个0
private static final int TIDYING = 2 << COUNT_BITS;
// 3 * 2^29 = 1610612736
// 1100000000000000000000000000000 ，总共29个0
private static final int TERMINATED = 3 << COUNT_BITS;
线程池控制状态
/*
* 线程池的状态控制熟悉，ctl，可以计算出两个当前线程的其它状态
* - workerCount 代表当前当前有效的线程数量
* - runState 代表当前线程池的状态，正在运行，还是已经关闭了
*/
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
// 2^29 - 1
// 29个1。 11111111111111111111111111111
private static final int CAPACITY = (1 << COUNT_BITS) - 1;
// ~CAPACITY = 11100000000000000000000000000000
// 后面29个0
private static int runStateOf(int c) { return c & ~CAPACITY; }
// 线程c的数量要小于CAPACITY，小于500万，一般都不会有这么多的线程的
private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
模拟运行
1 先给一段模拟运行的代码
private static ExecutorService demo() {
ExecutorService threadPool = Executors.newFixedThreadPool(2);
for (int i = 0; i < 4; i++) {
threadPool.execute(() -> sleep(1000));
}
return threadPool;
}
public static void sleep(int time){
try {
Thread.sleep(time);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
2 看源码，真正创建核心线程的部分，只有被红色框框圈起来的地方。
- 从ctl(线程池控制状态)中获取当前的状态
- 基础数据结构的时候提到过，通过ctl可以计算出当前线程的数量，即workerCount
- 然后创建核心线程，创建核心线程成功后返回
根据我们上面的案例，做个简单的流程梳理：
1. 提交第一个任务的时候，ctl是默认值即RUNNING值为11100000000000000000000000000000，29个0
2. workerCountOf(c)，里面与CAPCITY进行&操作。
- 11100000000000000000000000000000
- 00011111111111111111111111111111
3 两者相&得0，核心线程数默认情况下是0小于，创建时指定的corePoolSize
4. 进行addWorker操作
image-20200209215004777.png
3 看下addWorker里面又做了什么事情呢，代码里面看起来做了很多事情。但是其实就三件事情...
- 设置ctl的值
- 但是中间有一步，如果线程的数量大于最大线程，或者核心线程数大于设置的maximumPoolSize线程数，直接返回false，不进行下面的操作
- ctl的值增加之后，则new Woker(task)，新建线程，再构建new Worker的生活，其内部会调用
this.thread = getThreadFactory().newThread(this);即创建一个新的线程- 加锁，做一些新增worker线程后的操作
- 将workers线程都放到一个HashSet中
- largestPoolSize用来跟踪，线程池中曾经最大创建过多少线程
- 启动线程
- 返回结果
/*
* firstTask 我们提交的任务
* core 是否添加为核心线程，根据上面判断，当任务数小于核心线程数的时候，这个参数值为true
*/
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
// 修改ctl的值
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
...
for (;;) {
int wc = workerCountOf(c);
// 如果线程的数量大于最大线程，或者核心线程数大于设置的maximumPoolSize线程数，直接返回false
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
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 rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && 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) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
4 addWorker返回为true之后，就直接返回了，我们的任务就在worker线程中执行了。
最后
- 首先提交的任务都会使用核心线程来执行，每次提交任务都会创建核心线程，直到核心线程达到maximumPoolSize为止
- 内部大量的使用ctl来控制线程池当前的状态
- 可以计算出当前线程池的状态，有几个线程
如果提问的话，可以问：
1 线程池有哪些状态？
2 线程池中的ctl属性可以用来做什么？
3 线程池中的核心线程创建过程？回答了1，2之后，第三个稍微提一下就可以了
后续还有线程池源码探索... 记得关注...
