公众平台官网注册北京seo实战培训班

1. ctl 原子整型变量

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

• ctl 包含两个字段
  • workerCount：表示线程池中实际生效的线程数；
  • runState：表示线程池运行状态（注意和线程状态进行区分），线程池状态包括以下几种：
    • RUNNING：可以接收新任务并可执行队列中的任务；
    • SHUTDOWN：不接收新任务，但可执行队列中的任务；
    • STOP：不接收新任务，不执行队列任务并且中断正在执行的任务；
    • TIDYING：所有任务已终止，workerCount 为0，将会运行钩子方法 terminated；
    • TERMINATED：terminated 方法调用完成的状态。

1. 线程池中实际生效线程的最大容量

//Integer.SIZE等于32
private static final int COUNT_BITS = Integer.SIZE - 3;
//实际有效线程的最大容量
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

• 实际生效最大线程数为
  2 29 − 1 2^{29} - 1229−1
• 为何使用int类型是因为相对于long运行的更快一点，如果将来int不够用，可以使用AtomicLong代替。

1. 线程池运行状态

// runState is stored in the high-order bits
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

这里我们仅需要知道只有运行（RUNNING）状态是小于0的，其他状态下都是大于等于0的。
4. 获取线程池运行状态

private static int runStateOf(int c)     { return c & ~CAPACITY; }

方法入参 c 即为 ctl，通过该方法位运算可以得到线程池的状态值，并与 3 中的状态进行比较来进行逻辑处理。
5. 获取线程池中当前实际有效的线程数量

private static int workerCountOf(int c)  { return c & CAPACITY; }

同上，方法入参 c 为 ctl 原子整形变量，通过位运算得到线程池中实际的线程数 workCount。
6. 工作线程集合

private final HashSet<Worker> workers = new HashSet<Worker>();

线程池中每一个有效线程都会被包装为 Worker 对象。
7. Worker 内部类

private final class Worker extends AbstractQueuedSynchronizer implements Runnable

• 类 Worker 主要用于维护运行任务线程的中断控制状态；
• 继承 AQS 实现了一个简单的不可重入互斥锁，而不是使用可重入锁，因为不希望工作任务在调用setCorePoolSize之类的池控制方法时能够重新获取锁;
• 为了在线程真正开始运行任务之前禁止中断，将锁状态初始化为负值，并在启动时清除它（runWorker中）。

1. 其他如 corePoolSize、maximumPoolSize、threadFactory、workQueue等就不做赘述了。

该案例不执行 shutdown 方法，这样可以保证线程池一直处于运行状态(RUNNING)

public static void main(String[] args) {ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2,0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(6),Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());for (int i = 0; i < 8; i++) {int num = i;threadPoolExecutor.execute(() -> {String threadName = Thread.currentThread().getName();System.out.println(threadName + " - " + num);System.out.println(threadName + " 开始睡眠...");try {//暂缓线程执行TimeUnit.MILLISECONDS.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(threadName +" 结束睡眠...");});}//threadPoolExecutor.shutdown();
}

跟踪 execute 方法源码，查看核心线程是如何被加添到池中的：

public void execute(Runnable command) {if (command == null)throw new NullPointerException();//获取线程池控制状态int c = ctl.get();//通过workerCountOf计算出实际线程数if (workerCountOf(c) < corePoolSize) {//未超过核心线程数，则新增 Worker 对象，true表示核心线程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);
}

根据方法内容和断点跟踪可以得出以下结论：

1. 核心线程数未超过 corePoolSize，每添加新的任务（command），都会创建新的线程（Worker中创建），即使有空闲线程存在；
2. 核心线程数等于corePoolSize后，如果继续添加新的任务（command），会将任务添加到阻塞队列 workQueue 中，等待调度；
3. 如果添加到队列失败，则检查 corePoolSize 是否小于 maximumPoolSize，如果小于则创建新的线程执行任务，直到线程总数 等于 maximumPoolSize；
4. 当线程数等于 maximumPoolSize 并且队列已满了，后续新增任务将会触发线程饱和策略。

上面代码中我们关心 addWorker 方法，它有两个参数，第一个是 Runnable 对象，第二参数是标记是否核心线程，true为核心线程，接下来看下源码：

private boolean addWorker(Runnable firstTask, boolean core) {retry:for (;;) {int c = ctl.get();// 省略部分代码......for (;;) {//core主要用于判断是否继续创建新线程int wc = workerCountOf(c);//workCount 大于总容量或者workCount大于核心线程或最大线程将直接返回if (wc >= CAPACITY ||wc >= (core ? corePoolSize : maximumPoolSize))return false;//通过CAS将c加1，也就是将workCount加1    if (compareAndIncrementWorkerCount(c))break retry;c = ctl.get();  // Re-read ctlif (runStateOf(c) != rs)continue retry;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();//省略部分代码......workers.add(w);int s = workers.size();if (s > largestPoolSize)largestPoolSize = s;workerAdded = true;......if (workerAdded) {//启动线程t.start();workerStarted = true;}}} finally {if (! workerStarted)addWorkerFailed(w);}return workerStarted;
}

从 addWorker 方法中，可以看到从 Worker 对象中获取到线程对象 t ，并调用 start 方法启动线程，那这个 t 线程是如何来的呢？
扩展：java retry:详解

接下来要看下 Worker 是如何创建线程的：

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {final Thread thread;/**初始执行任务，有可能为空*/Runnable firstTask;/**使用firstTask和来自线程工厂中的线程创建了 Worker 对象*/Worker(Runnable firstTask) {setState(-1); // inhibit interrupts until runWorkerthis.firstTask = firstTask;this.thread = getThreadFactory().newThread(this);}/**将run方法委托给runWorker执行*/public void run() {runWorker(this);}
}

Worker 类实现 Runnable 接口， Worker 类的构造方法中 this.thread = getThreadFactory().newThread(this)比较关键，这行代码的意思是说使用当前 Worker 对象创建了一个线程，那其实也就是说 thread 对象和 当前 Worker 对象中调用的 run 方法是一样的。到这一步我们可以得出上一步 addWorker 方法中的 t.start 调用的其实就是 Worker 类中的 run方法。

那 runWorker 又是如何运行的呢？

final void runWorker(Worker w) {Thread wt = Thread.currentThread();//获取要执行的任务Runnable task = w.firstTask;w.firstTask = null;w.unlock(); // allow interruptsboolean completedAbruptly = true;//轮询调用 getTask 用于获取任务while (task != null || (task = getTask()) != null) {w.lock();//省略部分代码......//执行run方法task.run();//省略部分代码......}
}

runWorker 中使用 while 循环，不断调用 getTask 去获取新任务。

最后看下 getTask 方法做了哪些事：

private Runnable getTask() {boolean timedOut = false; //无限循环for (;;) {int c = ctl.get();int rs = runStateOf(c);// 检查队列是否为空if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {decrementWorkerCount();return null;}//获取运行线程数，根据allowCoreThreadTimeOut决定是否允许定时等待int wc = workerCountOf(c);boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;//线程超时并且队列为空时通过CAS将实际运行线程数减1if ((wc > maximumPoolSize || (timed && timedOut))&& (wc > 1 || workQueue.isEmpty())) {if (compareAndDecrementWorkerCount(c))return null;continue;}try {//允许超时则调用队列的poll方法定时等待//否则调用take获取任务Runnable r = timed ?workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :workQueue.take();//获取任务，返回结果if (r != null)return r;//继续循环，并且置超时标识为truetimedOut = true;} catch (InterruptedException retry) {timedOut = false;}}
}

通过以上源码可以看出：

1. 在for无限循环中，通过不断的检查线程池状态和队列容量，来获取可执行任务；
2. 在 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take();代码中，分为两种情况
   • timed 为 true，允许淘汰 Worker，即实际运行的线程，则通过
     workQueue.poll的方式定时等待拉取任务，如果在指定keepAliveTime时间内获取任务则返回，如果没有任务则继续for循环并直到timed等于false；
   • timed 为 false，则会调用 workQueue.take 方法，队列中 take 方法的含义是当队列有任务时，立即返回队首任务，没有任务时则一直阻塞当前线程，直到有新任务才返回。

下面简单画了一下核心线程的序列图：

线程池当未调用 shutdown 方法时，是通过队列的 take 方法阻塞核心线程（Worker）的 run 方法从而保证核心线程不被销毁的。