Java并发：线程池实现原理

一、总览

线程池类ThreadPoolExecutor的相关类需要先了解：

Executor：位于最顶层，只有一个 execute(Runnable runnable) 方法，用于提交任务。

ExecutorService ：在 Executor 接口的基础上添加了很多的接口方法，提交任务，获取结果，关闭线程池。

AbstractExecutorService：实现了ExecutorService 接口，然后在其基础上实现了几个实用的方法，这些方法提供给子类进行调用。

ThreadPoolExecutor：线程池类

Executors：最常用的用于生成 ThreadPoolExecutor 的实例的工具类

FutureTask：Runnable, Future -> RunnableFuture -> FutureTask

FutureTask 通过 RunnableFuture 间接实现了 Runnable 接口，所以每个 Runnable 通常都先包装成 FutureTask，然后调用 executor.execute(Runnable command) 将其提交给线程池

Runnable 的 void run() 方法是没有返回值的，如果我们需要的话，会在 submit 中指定第二个参数作为返回值。

Callable：Callable 也是因为线程池的需要，所以才有了这个接口。它和 Runnable 的区别在于 run() 没有返回值，而 Callable 的 call() 方法有返回值

二、线程池状态

线程池中的各个状态：

RUNNING：这个没什么好说的，这是最正常的状态：接受新的任务，处理等待队列中的任务

SHUTDOWN：不接受新的任务提交，但是会继续处理等待队列中的任务

STOP：不接受新的任务提交，不再处理等待队列中的任务，中断正在执行任务的线程

TIDYING：所有的任务都销毁了，workCount 为 0。线程池的状态在转换为 TIDYING 状态时，会执行钩子方法 terminated()

TERMINATED：terminated() 方法结束后，线程池的状态就会变成这个

状态转换：

RUNNING -> SHUTDOWN：当调用了 shutdown() 后，会发生这个状态转换，这也是最重要的

(RUNNING or SHUTDOWN) -> STOP：当调用 shutdownNow() 后，会发生这个状态转换，这下要清楚 shutDown() 和 shutDownNow() 的区别了

SHUTDOWN -> TIDYING：当任务队列和线程池都清空后，会由 SHUTDOWN 转换为 TIDYING

STOP -> TIDYING：当任务队列清空后，发生这个转换

TIDYING -> TERMINATED：这个前面说了，当 terminated() 方法结束后

ThreadPoolExecutor采用一个 32 位的整数来存放线程池的状态和当前池中的线程数，其中高 3 位用于存放线程池状态，低 29 位表示线程数。

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

// 这里 COUNT_BITS 设置为 29(32-3)，意味着前三位用于存放线程状态，后29位用于存放线程数

// 很多初学者很喜欢在自己的代码中写很多 29 这种数字，或者某个特殊的字符串，然后分布在各个地方，这是非常糟糕的

private static final int COUNT_BITS = Integer.SIZE - 3;

// 000 11111111111111111111111111111

// 这里得到的是 29 个 1，也就是说线程池的最大线程数是 2^29-1=536870911

// 以我们现在计算机的实际情况，这个数量还是够用的

private static final int CAPACITY = (1 << COUNT_BITS) - 1;

// 我们说了，线程池的状态存放在高 3 位中

// 运算结果为 111跟29个0：111 00000000000000000000000000000

private static final int RUNNING = -1 << COUNT_BITS;

// 000 00000000000000000000000000000

private static final int SHUTDOWN = 0 << COUNT_BITS;

// 001 00000000000000000000000000000

private static final int STOP = 1 << COUNT_BITS;

// 010 00000000000000000000000000000

private static final int TIDYING = 2 << COUNT_BITS;

// 011 00000000000000000000000000000

private static final int TERMINATED = 3 << COUNT_BITS;

// 将整数 c 的低 29 位修改为 0，就得到了线程池的状态

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

// 将整数 c 的高 3 为修改为 0，就得到了线程池中的线程数

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

private static int ctlOf(int rs, int wc) { return rs | wc; }

private static boolean runStateLessThan(int c, int s) {

return c < s;

}

private static boolean runStateAtLeast(int c, int s) {

return c >= s;

}

private static boolean isRunning(int c) {

return c < SHUTDOWN;

}

三、线程池参数

通过ThreadPoolExecutor构造函数来看线程池参数：

public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,

long keepAliveTime, TimeUnit unit,

BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory,

RejectedExecutionHandler handler) {

if (corePoolSize < 0 || maximumPoolSize <= 0

|| maximumPoolSize < corePoolSize || keepAliveTime < 0)

throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)

throw new NullPointerException();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.workQueue = workQueue;

this.keepAliveTime = unit.toNanos(keepAliveTime);

this.threadFactory = threadFactory;

this.handler = handler;

}

corePoolSize：线程池中核心线程的数量。当提交一个任务时，线程池会新建一个线程来执行任务，直到当前线程数等于corePoolSize。如果调用了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。

maximumPoolSize：线程池中允许的最大线程数。线程池的阻塞队列满了之后，如果还有任务提交，如果当前的线程数小于maximumPoolSize，则会新建线程来执行任务。注意，如果使用的是无界队列，该参数也就没有什么效果了。

keepAliveTime：空闲线程的保活时间，如果某线程的空闲时间超过这个值都没有任务给它做，那么可以被关闭了。注意这个值并不会对所有线程起作用，如果线程池中的线程数少于等于核心线程数 corePoolSize，那么这些线程不会因为空闲太长时间而被关闭，当然，也可以通过调用allowCoreThreadTimeOut(true)使核心线程数内的线程也可以被回收

unit：keepAliveTime的单位。TimeUnit

workQueue：

用来保存等待执行的任务的阻塞队列，等待的任务必须实现Runnable接口。我们可以选择如下几种：

ArrayBlockingQueue：基于数组结构的有界阻塞队列，FIFO。

LinkedBlockingQueue：基于链表结构的有界阻塞队列，FIFO。

SynchronousQueue：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作，反之亦然。

threadFactory：用于设置创建线程的工厂。

handler：

RejectedExecutionHandler，线程池的拒绝策略。

所谓拒绝策略，是指将任务添加到线程池中时，线程池拒绝该任务所采取的相应策略。当向线程池中提交任务时，如果此时线程池中的线程已经饱和了，而且阻塞队列也已经满了，则线程池会选择一种拒绝策略来处理该任务。

线程池提供了四种拒绝策略：（重写RejectedExecutionHandler.rejectedExecution(Runnable, ThreadPoolExecutor)）

　　AbortPolicy：直接抛出异常，默认策略；

　　CallerRunsPolicy：用调用者所在的线程来执行任务；

　　DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；

　　DiscardPolicy：直接丢弃任务；

当然我们也可以实现自己的拒绝策略，例如记录日志等等，实现RejectedExecutionHandler接口写rejectedExecution方法即可。

四、线程池创建

Executor工具类提供了三种线程池创建方式：

FixedThreadPool ：可重用固定线程数的线程池

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>());

}

corePoolSize 和 maximumPoolSize都设置为创建FixedThreadPool时指定的参数nThreads，意味着当线程池满时且阻塞队列也已经满时，如果继续提交任务，则会直接走拒绝策略，该线程池不会再新建线程来执行任务，而是直接走拒绝策略。FixedThreadPool使用的是默认的拒绝策略，即AbortPolicy，则直接抛出异常。

keepAliveTime设置为0L，表示空闲的线程会立刻终止。

workQueue则是使用LinkedBlockingQueue，但是没有设置范围，那么则是最大值（Integer.MAX_VALUE），这基本就相当于一个无界队列了。使用该“无界队列”则会带来哪些影响呢？当线程池中的线程数量等于corePoolSize 时，如果继续提交任务，该任务会被添加到阻塞队列workQueue中，当阻塞队列也满了之后，则线程池会新建线程执行任务直到maximumPoolSize。由于FixedThreadPool使用的是“无界队列”LinkedBlockingQueue，那么maximumPoolSize参数无效，同时指定的拒绝策略AbortPolicy也将无效。而且该线程池也不会拒绝提交的任务，如果客户端提交任务的速度快于任务的执行，那么keepAliveTime也是一个无效参数。

SingleThreadExecutor：只有一个线程的固定线程池

public static ExecutorService newSingleThreadExecutor() {

return new FinalizableDelegatedExecutorService

(new ThreadPoolExecutor(1, 1,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue<Runnable>()));

}

为单一worker线程的线程池，SingleThreadExecutor把corePool和maximumPoolSize均被设置为1，和FixedThreadPool一样使用的是无界队列LinkedBlockingQueue,所以带来的影响和FixedThreadPool一样。

CachedThreadPool：根据需要创建新线程的线程池

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue<Runnable>());

}

CachedThreadPool的corePool为0，maximumPoolSize为Integer.MAX_VALUE，这就意味着所有的任务一提交就会加入到阻塞队列中。

keepAliveTime这是为60L，unit设置为TimeUnit.SECONDS，意味着空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。

阻塞队列采用的SynchronousQueue，SynchronousQueue是一个没有元素的阻塞队列，加上corePool = 0 ，maximumPoolSize = Integer.MAX_VALUE，这样就会存在一个问题，如果主线程提交任务的速度远远大于CachedThreadPool的处理速度，则CachedThreadPool会不断地创建新线程来执行任务，这样有可能会导致系统耗尽CPU和内存资源，所以在使用该线程池是，一定要注意控制并发的任务数，否则创建大量的线程可能导致严重的性能问题。

五、执行过程

提交任务：

线程池根据业务不同的需求提供了两种方式提交任务：Executor.execute()、ExecutorService.submit()。其中ExecutorService.submit()可以获取该任务执行的Future。

execute()

执行流程如下：

（1）如果线程池当前线程数小于corePoolSize，则调用addWorker创建新线程执行任务，成功返回true，失败执行步骤2。

（2）如果线程池处于RUNNING状态，则尝试加入阻塞队列，如果加入阻塞队列成功，则尝试进行Double Check，如果加入失败，则执行步骤3。

　　如果加入阻塞队列成功了，则会进行一个Double Check的过程。Double Check过程的主要目的是判断加入到阻塞队里中的线程是否可以被执行。如果线程池不是RUNNING状态，则调用remove()方法从阻塞队列中删除该任务，然后调用reject()方法处理任务。否则需要确保还有线程执行。

（3）如果线程池不是RUNNING状态或者加入阻塞队列失败，则尝试创建新线程直到maxPoolSize，如果失败，则调用reject()方法运行相应的拒绝策略。

public void execute(Runnable command) {

if (command == null)

throw new NullPointerException();

// 前面说的那个表示 “线程池状态” 和 “线程数” 的整数

int c = ctl.get();

// 如果当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务，

// 创建一个新的线程，并把当前任务 command 作为这个线程的第一个任务(firstTask)

if (workerCountOf(c) < corePoolSize) {

// 添加任务成功，那么就结束了。提交任务嘛，线程池已经接受了这个任务，这个方法也就可以返回了

// 至于执行的结果，到时候会包装到 FutureTask 中。

// 返回 false 代表线程池不允许提交任务

if (addWorker(command, true))

return;

c = ctl.get();

}

// 到这里说明，要么当前线程数大于等于核心线程数，要么刚刚 addWorker 失败了

// 如果线程池处于 RUNNING 状态，把这个任务添加到任务队列 workQueue 中

if (isRunning(c) && workQueue.offer(command)) {

/* 这里面说的是，如果任务进入了 workQueue，我们是否需要开启新的线程

* 因为线程数在 [0, corePoolSize) 是无条件开启新的线程

* 如果线程数已经大于等于 corePoolSize，那么将任务添加到队列中，然后进到这里

int recheck = ctl.get();

// 如果线程池已不处于 RUNNING 状态，那么移除已经入队的这个任务，并且执行拒绝策略

if (! isRunning(recheck) && remove(command))

reject(command);

// 如果线程池还是 RUNNING 的，并且线程数为 0，那么开启新的线程

// 到这里，我们知道了，这块代码的真正意图是：担心任务提交到队列中了，但是线程都关闭了

else if (workerCountOf(recheck) == 0)

addWorker(null, false);

}

// 如果 workQueue 队列满了，那么进入到这个分支

// 以 maximumPoolSize 为界创建新的 worker，

// 如果失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略

else if (!addWorker(command, false))

reject(command);

}

addWorker

在这里需要好好理论addWorker中的参数，在execute()方法中，有三处调用了该方法：

第一次：workerCountOf(c) < corePoolSize ==> addWorker(command, true)，这个很好理解，当然线程池的线程数量小于 corePoolSize ，则新建线程执行任务即可，在执行过程core == true，内部与corePoolSize比较即可。

第二次：加入阻塞队列进行Double Check时，else if (workerCountOf(recheck) == 0) ==>addWorker(null, false)。如果线程池中的线程==0，按照道理应该该任务应该新建线程执行任务，但是由于已经该任务已经添加到了阻塞队列，那么就在线程池中新建一个空线程，然后从阻塞队列中取线程即可。

第三次：线程池不是RUNNING状态或者加入阻塞队列失败：else if (!addWorker(command, false))，这里core == fase，则意味着是与maximumPoolSize比较。

执行流程：

（1）判断当前线程是否可以添加任务，如果可以则进行下一步，否则return false；

rs >= SHUTDOWN ，表示当前线程处于SHUTDOWN ，STOP、TIDYING、TERMINATED状态

rs == SHUTDOWN , firstTask != null时不允许添加线程，因为线程处于SHUTDOWN 状态，不允许添加任务

rs == SHUTDOWN , firstTask == null，但workQueue.isEmpty() == true，不允许添加线程，因为firstTask == null是为了添加一个没有任务的线程然后再从workQueue中获取任务的，如果workQueue == null，则说明添加的任务没有任何意义。

（2）内嵌循环，通过CAS worker + 1

（3）获取主锁mailLock，如果线程池处于RUNNING状态获取处于SHUTDOWN状态且 firstTask == null，则将任务添加到workers Queue中，然后释放主锁mainLock，然后启动线程，然后return true，如果中途失败导致workerStarted= false，则调用addWorkerFailed()方法进行处理。

// 第一个参数是准备提交给这个线程执行的任务，之前说了，可以为 null

// 第二个参数为 true 代表使用核心线程数 corePoolSize 作为创建线程的界线，也就说创建这个线程的时候，

// 如果线程池中的线程总数已经达到 corePoolSize，那么不能响应这次创建线程的请求

// 如果是 false，代表使用最大线程数 maximumPoolSize 作为界线

private boolean addWorker(Runnable firstTask, boolean core) {

retry:

for (;;) {

int c = ctl.get();

int rs = runStateOf(c);

// 这个非常不好理解

// 如果线程池已关闭，并满足以下条件之一，那么不创建新的 worker：

// 1. 线程池状态大于 SHUTDOWN，其实也就是 STOP, TIDYING, 或 TERMINATED

// 2. firstTask != null

// 3. workQueue.isEmpty()

// 简单分析下：

// 还是状态控制的问题，当线程池处于 SHUTDOWN 的时候，不允许提交任务，但是已有的任务继续执行

// 当状态大于 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;

// 如果成功，那么就是所有创建线程前的条件校验都满足了，准备创建线程执行任务了

// 这里失败的话，说明有其他线程也在尝试往线程池中创建线程

if (compareAndIncrementWorkerCount(c))

break retry;

// 由于有并发，重新再读取一下 ctl

c = ctl.get();

// 正常如果是 CAS 失败的话，进到下一个里层的for循环就可以了

// 可是如果是因为其他线程的操作，导致线程池的状态发生了变更，如有其他线程关闭了这个线程池

// 那么需要回到外层的for循环

if (runStateOf(c) != rs)

continue retry;

// else CAS failed due to workerCount change; retry inner loop

}

* 到这里，我们认为在当前这个时刻，可以开始创建线程来执行任务了，

* 因为该校验的都校验了，至于以后会发生什么，那是以后的事，至少当前是满足条件的

// worker 是否已经启动

boolean workerStarted = false;

// 是否已将这个 worker 添加到 workers 这个 HashSet 中

boolean workerAdded = false;

Worker w = null;

try {

final ReentrantLock mainLock = this.mainLock;

// 把 firstTask 传给 worker 的构造方法

w = new Worker(firstTask);

// 取 worker 中的线程对象，之前说了，Worker的构造方法会调用 ThreadFactory 来创建一个新的线程

final Thread t = w.thread;

if (t != null) {

// 这个是整个类的全局锁，持有这个锁才能让下面的操作“顺理成章”，

// 因为关闭一个线程池需要这个锁，至少我持有锁的期间，线程池不会被关闭

mainLock.lock();

try {

int c = ctl.get();

int rs = runStateOf(c);

// 小于 SHUTTDOWN 那就是 RUNNING，这个自不必说，是最正常的情况

// 如果等于 SHUTDOWN，前面说了，不接受新的任务，但是会继续执行等待队列中的任务

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) {

// 启动线程

t.start();

workerStarted = true;

}

} finally {

// 如果线程没有启动，需要做一些清理工作，如前面 workCount 加了 1，将其减掉

if (! workerStarted)

addWorkerFailed(w);

}

// 返回线程是否启动成功

return workerStarted;

Woker内部类

从Worker的源码中我们可以看到Woker继承AQS，实现Runnable接口，所以可以认为Worker既是一个可以执行的任务，也可以达到获取锁释放锁的效果。这里继承AQS主要是为了方便线程的中断处理。这里注意两个地方：构造函数、run()。构造函数主要是做三件事：1.设置同步状态state为-1，同步状态大于0表示就已经获取了锁，2.设置将当前任务task设置为firstTask，3.利用Worker本身对象this和ThreadFactory创建线程对象。

private final class Worker extends AbstractQueuedSynchronizer

implements Runnable {

private static final long serialVersionUID = 6138294804551838833L;

// task 的thread

final Thread thread;

// 运行的任务task

Runnable firstTask;

volatile long completedTasks;

Worker(Runnable firstTask) {

//设置AQS的同步状态private volatile int state，是一个计数器，大于0代表锁已经被获取

setState(-1);

this.firstTask = firstTask;

// 利用ThreadFactory和 Worker这个Runnable创建的线程对象

this.thread = getThreadFactory().newThread(this);

}

// 任务执行

public void run() {

runWorker(this);

}

runWorker

运行流程：

（1）根据worker获取要执行的任务task，然后调用unlock()方法释放锁，这里释放锁的主要目的在于中断，因为在new Worker时，设置的state为-1，调用unlock()方法可以将state设置为0，这里主要原因就在于interruptWorkers()方法只有在state >= 0时才会执行；

（2）通过getTask()获取执行的任务，调用task.run()执行，当然在执行之前会调用worker.lock()上锁，执行之后调用worker.unlock()放锁；

（3）在任务执行前后，可以根据业务场景自定义beforeExecute() 和 afterExecute()方法，则两个方法在ThreadPoolExecutor中是空实现；

（4）如果线程执行完成，则会调用getTask()方法从阻塞队列中获取新任务，如果阻塞队列为空，则根据是否超时来判断是否需要阻塞；

（5）task == null或者抛出异常（beforeExecute()、task.run()、afterExecute()均有可能）导致worker线程终止，则调用processWorkerExit()方法处理worker退出流程。

// 此方法由 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 {

// 如果到这里，需要执行线程关闭：

// 1. 说明 getTask 返回 null，也就是说，这个 worker 的使命结束了，执行关闭

// 2. 任务执行过程中发生了异常

// 第一种情况，已经在代码处理了将 workCount 减 1，这个在 getTask 方法分析中会说

// 第二种情况，workCount 没有进行处理，所以需要在 processWorkerExit 中处理

// 限于篇幅，我不准备分析这个方法了，感兴趣的读者请自行分析源码

processWorkerExit(w, completedAbruptly);

}

getTask()

// 此方法有三种可能：

// 1. 阻塞直到获取到任务返回。我们知道，默认 corePoolSize 之内的线程是不会被回收的，

// 它们会一直等待任务

// 2. 超时退出。keepAliveTime 起作用的时候，也就是如果这么多时间内都没有任务，那么应该执行关闭

在此我向大家推荐一个架构学习交流圈：609164807 帮助突破瓶颈提升思维能力

// 3. 如果发生了以下条件，此方法必须返回 null:

// - 池中有大于 maximumPoolSize 个 workers 存在(通过调用 setMaximumPoolSize 进行设置)

// - 线程池处于 SHUTDOWN，而且 workQueue 是空的，前面说了，这种不再接受新的任务

// - 线程池处于 STOP，不仅不接受新的线程，连 workQueue 中的线程也不再执行

private Runnable getTask() {

boolean timedOut = false; // Did the last poll() time out?

retry:

for (;;) {

int c = ctl.get();

int rs = runStateOf(c);

// 两种可能

// 1. rs == SHUTDOWN && workQueue.isEmpty()

// 2. rs >= STOP

if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {

// CAS 操作，减少工作线程数

decrementWorkerCount();

return null;

}

boolean timed; // Are workers subject to culling?

for (;;) {

int wc = workerCountOf(c);

// 允许核心线程数内的线程回收，或当前线程数超过了核心线程数，那么有可能发生超时关闭

timed = allowCoreThreadTimeOut || wc > corePoolSize;

// 这里 break，是为了不往下执行后一个 if (compareAndDecrementWorkerCount(c))

// 两个 if 一起看：如果当前线程数 wc > maximumPoolSize，或者超时，都返回 null

// 那这里的问题来了，wc > maximumPoolSize 的情况，为什么要返回 null？

// 换句话说，返回 null 意味着关闭线程。

// 那是因为有可能开发者调用了 setMaximumPoolSize 将线程池的 maximumPoolSize 调小了

if (wc <= maximumPoolSize && ! (timedOut && timed))

break;

if (compareAndDecrementWorkerCount(c))

return null;

c = ctl.get(); // Re-read ctl

// compareAndDecrementWorkerCount(c) 失败，线程池中的线程数发生了改变

if (runStateOf(c) != rs)

continue retry;

// else CAS failed due to workerCount change; retry inner loop

}

// wc <= maximumPoolSize 同时没有超时

try {

// 到 workQueue 中获取任务

Runnable r = timed ?

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

workQueue.take();

if (r != null)

return r;

timedOut = true;

} catch (InterruptedException retry) {

// 如果此 worker 发生了中断，采取的方案是重试

// 解释下为什么会发生中断，这个读者要去看 setMaximumPoolSize 方法，

// 如果开发者将 maximumPoolSize 调小了，导致其小于当前的 workers 数量，

// 那么意味着超出的部分线程要被关闭。重新进入 for 循环，自然会有部分线程会返回 null

timedOut = false;

}

在此我向大家推荐一个架构学习交流群。交流学习群号874811168 里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化、分布式架构等这些成为架构师必备的知识体系。还能领取免费的学习资源，目前受益良多

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 199,902评论 5赞 468
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 84,037评论 2赞 377
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 146,978评论 0赞 332
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 53,867评论 1赞 272
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 62,763评论 5赞 360
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,104评论 1赞 277
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,565评论 3赞 390
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,236评论 0赞 254
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,379评论 1赞 294
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,313评论 2赞 317
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,363评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,034评论 3赞 315
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,637评论 3赞 303
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,719评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,952评论 1赞 255
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,371评论 2赞 346
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 41,948评论 2赞 341

Java并发：线程池实现原理

一、总览

推荐阅读更多精彩内容