本文带着以下问题来读：
execute 方法里为啥要用 workQueue.offer(command)这个非阻塞方法呢，而不用 put 等阻塞方法呢？
线程池收到 Runnable 任务紧就 start 执行了，为什么还要将任务放入集合（workers.add(w)）呢? workers 集合存在的意义是什么呢？
workers 与 workerQueue 与 ctl 的关系？
getTask 方法中为啥使用 workQueue.poll(num, timeUnit) 和 take()阻塞方法呢，为啥不使用非阻塞方法呢？
线程池里存放的是线程吗？
线程池使用了两个锁 lock，worker 使用一个，reentrantLock 使用一个，作用分别是什么？
线程池里怎么区分空闲线程和执行中线程？
理解 ThreadPoolExecutor，甚至任何其他的类或组件，我觉得从两个点出发会更顺滑：他的数据结构和结构中的属性变化
所以，现在我们看下 ThreadPoolExecutor 的数据结构。代码如下：
private final BlockingQueue<Runnable> workQueue;private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));private final HashSet<Worker> workers;class Worker final Thread thread; Runnable firstTask; volatile long completedTasks;
复制代码
做个比喻，在一个森林中，有个超高级的城堡，城堡太大了，为了防止迷路，客人来的时候，自进门那一刻起，就自动给客人配备一辆车和一个保姆。
现在，线程池就是城堡，worker 就是那辆车，thread 就是那个保姆，task 就是那个客人。
他们的关系是，线程池会有 0 或多个 worker，每个 worker 配备一个 thread 线程和一个 task 任务。
workers 是城堡里的客房。城堡太火爆了，装不下了，城堡为这些人提供了临时露营帐篷，workQueue 就是那个露营帐篷。露营帐篷不是一般的帐篷，自带阻塞
ctl 是一个巧妙的设计，既表示 workerCount 又表示 runState
本文将 ThreadPoolExecutor 高深的位运算转换为二进制，以便更直观的理解方法和属性的使用。对加入线程池，执行 worker 的线程，释放 worker 的线程，终止线程池等进行细致的理解，以求每个判断，每行代码都能理解。
状态
NOTE: ThreadPoolExecutor 代码中的采用了高效的位运算，但阅读源码时不好直观理解，所以我将他们转成十进制，直观大家便于理解。
转换时借助以下方法 1、二进制 -> 十进制 Integer.parseInt("00111100", 2) 2、十进制 -> 二进制 Integer.toBinaryString(1)
ctl 即是又是 既是 workerCount：表示有效的线程数 又是 runState： 表示线程池的状态
/** * * <pre> * ctl即是又是 * workerCount：表示有效的线程数 * runState： 表示线程池的状态 * </pre> * <pre> * Run state is stored in the high-order bits; worker count is stored in the low-order bits. 解释如下: * | --- 高位 --- | --- 低位 --- | * | -536870912 --> 0 --> 536870912 | * | --- 线程状态 --- | --- 线程数量 --- | * 所以线程状态的变化轨迹是从 -536870912 开始递增，一直到 0；线程数量的变化轨迹是从0 开始递增，一直到 536870912 * 2. ctl直接等于 536870910，再定义两个线程，debug看效果 do it by practise * </pre> * * <pre> * ctl的初始值：-536870912 * ctl = ctlOf(RUNNING, 0): -536870912 -> 11100000000000000000000000000000 -> size: 32 * </pre> */private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
// COUNT_BITS = 29private static final int COUNT_BITS = Integer.SIZE - 3;
/** * <pre> * (1 << COUNT_BITS) = (1 << 29) -> 536870912 -> 100000000000000000000000000000 -> size: 30 * CAPACITY = ((1 << 29) - 1) -> 536870911 -> 11111111111111111111111111111 -> size: 29 * ~CAPACITY = ~((1 << 29) - 1) -> -536870912 -> 11100000000000000000000000000000 -> size: 32 * </pre> */private static final int CAPACITY = (1 << COUNT_BITS) - 1;
/** * NOTE: 这几个状态值是有数值顺序的，所以这几个状态值才可以进行大于、小于等操作 * * runState is stored in the high-order bits * <pre> * COUNT_BITS = 29 * RUNNING (-1 << 29): -536870912 -> 11100000000000000000000000000000 -> size: 32 * SHUTDOWN (0 << 29): 0 -> 0 -> -> size: 1 * STOP (1 << 29): 536870912 -> 100000000000000000000000000000 -> size: 30 * TIDYING (2 << 29): 1073741824 -> 1000000000000000000000000000000 -> size: 31 * TERMINATED (3 << 29): 1610612736 -> 1100000000000000000000000000000 -> size: 31 * </pre> * * 》》》重要知识点出现了：这几个状态值是有数值顺序的，所以这几个状态值才可以进行大于、小于等操作 》》》 * * 通过实践得出：这里的常量只是状态的边界值。换句话说，每个状态其实是一个范围，具体如下 * runState: ------- RUNNING -------- )[ ---------- SHUTDOWN --------- )[ ------------ STOP ---------- )[ ------------- TIDYING -------- )[ TERMINATED * 11100000000000000000000000000000 ~ 0 ~ 100000000000000000000000000000 ~ 1000000000000000000000000000000 ~ 1100000000000000000000000000000 ~ 无穷 */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;
复制代码
再次强调：runState 的几个常量仅是状态的边界值。换句话说，每个状态其实是一个范围
正是由于每个状态其实是一个范围，状态常量仅是状态范围的边界。介于次，状态方法的使用就简单明了了
状态方法
/** * 这个方法：返回负数说明线程状态是RUNNING；返回0说明线程状态是SHUTDOWN；理论上不返回正数 * * <pre> * 由于 * ~CAPACITY = ~((1 << 29) - 1) -> -536870912 -> 11100000000000000000000000000000 -> size: 32 * ctl = ctlOf(RUNNING,0) -> -536870912 -> 11100000000000000000000000000000 -> size: 32 * 所以 * c=ctl时，ctl & ~CAPACITY -> -536870912 & -536870912 -> 11100000000000000000000000000000 = -536870912， * 所以 * 随着ctl ++，runStateOf方法结果也是负数，并从-536870912开始递 +1，一直到 0，所以也可以是说负数表示线程状态是RUNNING(运行状态)时 * * 举例： * 当第一次ctl ++后，ctl -> -536870911 -> 11100000000000000000000000000001 * 此时，ctl & ~CAPACITY -> -536870911 & -536870912 -> 11100000000000000000000000000001 & 11100000000000000000000000000000 * NOTE: 当runStateOf等于0时，线程状态就变成了SHUTDOWN * </pre> */private static int runStateOf(int c) { return c & ~CAPACITY; }
/** * <pre> * 由于 * CAPACITY = (1 << 29) - 1 -> 536870911 -> 11111111111111111111111111111 -> size: 29 * ctl = ctlOf(RUNNING, 0) -> -536870912 -> 11100000000000000000000000000000 -> size: 32 * 所以 * c=ctl时，ctl & CAPACITY -> -536870912 & 536870911 -> 00000000000000000000000000000000 = 0 * 所以 * 随着ctl ++，所以workerCountOf方法结果从0开始递 +1，一直到 536870911 * </pre> */private static int workerCountOf(int c) { return c & CAPACITY; }
private static int ctlOf(int rs, int wc) { return rs | wc; }
复制代码
线程池的执行过程，这个网上说的很明白了
Tips => 正式开始前，再次强调 ctl 其值为正数时表示线程数，其值为负数时表示线程状态
添加任务方法 - execute
public void execute(Runnable command) { /* * Proceed in 3 steps: * 线程加入线程池的执行过程，见上图 */ int c = ctl.get(); // 当前线程数小于核心线程数 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; // 在addWorker里执行时，如果其他线程对线程池调用shutdown or shutdownNow or terminate and so on， // 那么addWorker返回false，从而走到这行代码 c = ctl.get(); } // =》isRunning(c) = c < SHUTDOWN =》记住一点：ctl小于0即是Running状态 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); // 如果其他线程对线程池调用shutdown or terminate相关方法，对于刚才加入队列的任务要删除调 if (! isRunning(recheck) && remove(command)) reject(command); // 假设线程池中只有一个运行着的线程:T1，当main线程走到这行代码时，T1运行完了，并对ctl执行了-1操作后就是0了，此时这行判断为true // 但是此时addWorker传入的任务是null，疑惑吗？这是因为代码执行到这时，任务task已经加入到workQueue队列了，而在runWorker方法中，如果worker的firstTask是null，那么会从workQueue队列里取任务task执行，所以此处传null给addWorker得以有机会执行t.start()，从而执行runWorker方法。__从这里看出一点：work count是不包括队列中任务的__ else if (workerCountOf(recheck) == 0) addWorker(null, false); // (1) } // 如果执行到这里，两种情况： // 1. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQueue已满。使用最大线程数的逻辑 // 2. 线程池已经不是RUNNING状态，即c >= SHUTDOWN。那为什么还要走addWorker方法呢，我的理解是：这是作者代码精简的结果，addWorker方法有c >= SHUTDOWN的判断逻辑 else if (!addWorker(command, false)) reject(command);}
复制代码
这里抛出一个问题(问题 A)：这里为啥要用 workQueue.offer(command)这个非阻塞方法呢，而不用 put 等阻塞方法呢？先想想，文末一起说说
添加任务方法 - addWorker 记住一个前提：进入这个方法的条件是当前线程数<=核心线程数，或队列已满 &当前线程数<=最大线程数。有了这个前提就好理解多了
private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c);
// 线程池不是RUNNING状态时触发 // 且，(rs不是0 或 firstTask不是null 或 队列是空) // 返回false if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false;
// 对c进行CAS操作，直到成功 for (;;) { int wc = workerCountOf(c); 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 { int rs = runStateOf(ctl.get());
// (rs == SHUTDOWN && firstTask == null)这种情况仅仅适用于execute方法的(1)处情况 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(); //(1) workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); } return workerStarted;}
复制代码
addWorker 方法一共做了两件事：
ctl 递增；
Worker 对象加入 workers 集合并 start Worker.thread 线程(即线程池中的线程)。再具体点说，这个方法主要是 start Worker.thread 线程。
既然是这样，那么有两个疑问：
再问个问题(问题 E)：线程池(ThreadPoolExecutor)中存放的是线程吗？不是，是一堆的 Worker 对象，Worker 既不是 thread 线程也不是要执行的任务。那么它是做啥的呢？
我们来看下 Worker 的构造方法
Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker (1) inhibit interrupts：抑制中断 this.firstTask = firstTask; // (2) this.thread = getThreadFactory().newThread(this); // (3)}
复制代码
setState(-1)：包含了一个很重要的点：worker 中的 thread 线程可以被中断的条件：aqs.state=0 从构造方法知道，我们要执行的任务成为 Worker 的一个字段，同时 Worker 还有一个 thread 字段，看 Worker 的(3)处代码，我觉得这行很关键，我改下它的同义写法：this.thread.target = this，即 worker 作为他自身的 thread 字段的值，从 Worker 的定义知道，Worker 本身也是 Runnable 的。所以，当执行 addWorker 方法的(1)处 t.start()时，我们的任务也跟着执行了，这个流程如图：
明白了这里，Worker.run()和 runWorker(Worker)怎么触发的就很容易理解了
执行任务方法 - runWorker
Worker的thread字段值，执行thread.start()方法，触发了此方法的执行。
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; // worker的lock用于区分线程是否空闲的 w.unlock(); // allow interrupts (b) boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) { w.lock(); // 这里为啥要加锁，结合 interruptIdleWorkers 方法一起思考？先透漏一点：w.lock() 将 w.state 设置为1，从而保证 w.thread 线程不能被中断
// 如果线程池正在停止，那么要保证当前线程是中断状态； // 如果不是的话，则要保证当前线程不是中断状态； // ctl > STOP if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { // 业务人员自己实现 beforeExecute(wt, task); try { task.run(); } catch (Throwable x) { throw new Error(x); } finally { // 业务人员自己实现 afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } // completedAbruptly变量来表示在执行任务过程中是否出现了异常，在processWorkerExit方法中会对该变量的值进行判断。 completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); }}
复制代码
runWorker 方法的目的就是执行任务(即 task.run())。它首先执行 Worker 的 firstTask，然后再从 workQueue 队列里取 task 继续执行。简单来说，就是取任务 执行，取任务 执行，取任务 执行。在这其中，怎么取，执行前中后会做什么事情，如 ctl 判断，线程中断检测，w.unlock()和 w.lock()等都很重要
怎么取：这是 getTask()方法的事情，稍后说
ctl 判断：runStateAtLeast(ctl.get(), STOP) => 是否 ctl.get() > STOP，当线程被中断了，这个方法才返回 true
w.unlock()和 w.lock()，这两个方法操作是用于区分线程是否忙碌/空闲的？为什么呢
因为：runWorker 中线程在执行任务时，线程是时刻被线程池管理和监控着呢。线程池可以视情况随时进行关闭（调用 shutdown）、立刻关闭（调用 shutdownNow）、终止（调用 tryTerminate）。我们回头看线程池的状态，其中 SHUTDOWN：不接收新任务，继续处理队列的任务；STOP：不接收新任务，不处理队列的任务，中断正在进行的任务。SHUTDOWN 状态下要实现的逻辑就是通过 worker 的 lock 实现的。
假设线程正在执行任务，此时线程池进行关闭，即调用 shutdown 方法。如果没有 worker.lock()，那么正执行任务的线程就会被打断，任务无法继续执行。这样 SHUTDOWN 状态的逻辑就无法完成了。
同时，w.unlock()和 w.lock()，为什么说他们可区分线程是否忙碌/空闲的呢。试想，worker 关联的线程被 lock 了，说明正在执行任务呢。所以说此线程是忙碌的线程
注意一点：getTask 方法是在 lock 之外的。所以，阻塞着的线程就是空闲线程了
worker 的 lock 用于区分线程是否空闲的。 结合 shutdown()方法一起理解，见下文 shutdown 的部分
从 while 条件可知：null 值对于 runWorker()来说有特殊用途：通知获取任务的工作线程结束并退出，所以 getTask 方法返回 null 时是很特殊的
执行任务方法 - getTask
private Runnable getTask() { boolean timedOut = false; // 上一次的poll()的调用是否超时?
for (;;) { int c = ctl.get();
// 这里需要记住文章开头的那些状态字段值，才反应的快些 // => c & ~CAPACITY int rs = runStateOf(c);
/* * 如果线程池状态rs >= SHUTDOWN，也就是非RUNNING状态，再进行以下判断： * 1. rs >= STOP，线程池是否正在stop； * 2. 阻塞队列是否为空。 * 如果以上条件满足，则整个判断条件为true。说明线程池突然终止， * 因为如果当前线程池状态的值是SHUTDOWN或以上时，不允许再向阻塞队列中添加任务 * * rs >= SHUTDOWN 说明当前线程池至少处于待关闭状态，不再接受新的任务 * rs >= STOP： 说明不需要在再处理任务了（即便任务在执行） * 所以，说明线程池在关闭，那就不执行任务task了 */ if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { // 线程池要/正在关闭了，所以返回null，这样外层的runWorker方法就可以退出了。 // 所以代码走到这里含义是此任务的工作线程就要退出了。 // 相应的，ctl当然随之要减一 decrementWorkerCount(); return null; }
// => c & CAPACITY int wc = workerCountOf(c); // timed：当前线程池中的线程数量是否超过了最大数量 或 核心线程允许超时 时为 true boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
// A：wc > maximumPoolSize什么场景下是true呢？答案是有人动态调整了最大线程数 // B：timeOut：poll超时 或 take被打断，再回到for循环时为 true；timed：如上 // C：wc > 1：线程数大于1 // D：workQueue.isEmpty()：队列为空 /// 线程退出条件 // A C 为 true => 线程池里线程太多了，当前线程要退出了 // A D 为 true => 线程池里线程太多了，且 队列里没有任务了，当前线程要退出了 // B C 为 true => 线程池里线程数量大于核心线程数量，且 核心线程允许超时，当前线程要退出了 // B D 为 true => 线程池里线程数量大于核心线程数量，且 核心线程允许超时，且 队列里没有任务了，当前线程要退出了 // 所以线程数量减一。同时return null，意味着此工作线程要退出了 if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { // 此线程要退出了，ctl随之减一 if (compareAndDecrementWorkerCount(c)) return null; // 如果减1失败，则for回来重试 continue; }
/// 程序第一次执行到这，B:timedOut:一定false // 如果A:false (C D是啥都行)，那么当前线程池会阻塞，直到队列有任务或超时，然后再回到“线程退出条件”代码，依当前条件决定线程是否退出 try { // 这行语句表达了一个想法：线程只要是存活着的，他就应该执行任务。没有任务时，就等着有任务 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); // (1) if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } }}
复制代码
这里有个疑问(问题 D)：getTask 方法的(1)处代码为什么要用阻塞的方法呢，不阻塞的方法不行吗，答案文末给出
addWorker 方法与 runWorker 方法就像是蓄水池中进水管和出水管，分析的时候需要两个结合的捋逻辑。而 getTask 方法是 runWorker 方法中的核心逻辑。而 getTask 方法中的条件判断逻辑更核心。同时，分析的时候，与 shutdown，shutdownNow，tryTerminate，awaitTermination 等方法的逻辑相互结合在一起会更清晰
以下是关闭相关的方法
shutdown 和 shutdownNow 方法比较相似，类比图如下：
shutdown
调用 shutdown()方法会进入 SHUTDOWN 状态。在 SHUTDOWN 状态下，线程池不接受新的任务，但是会继续执行任务队列中已有的任务。 怎么证明它此时不接收新的任务了呢，you need to do it by practise
通过调用 shutdown()关闭的线程池，关闭以后表现的行为就是不能再提交任务给线程池，但是在关闭前已经提交的任务仍旧会被执行。等到任务队列空了以后线程池才会进入关闭流程
public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(SHUTDOWN); interruptIdleWorkers(); onShutdown(); // hook for ScheduledThreadPoolExecutor } finally { mainLock.unlock(); } tryTerminate();}
复制代码
shutdown 方法核心由三部分组成：
advanceRunState(SHUTDOWN)：改线程池状态为 SHUTDOWN
interruptIdleWorkers()：中断线程池中空闲线程
tryTerminate()：Transitions to TERMINATED state if either (SHUTDOWN and pool and queue empty) or (STOP and pool empty)
advanceRunState
转换线程池状态为入参值，入参值只能是 SHUTDOWN or STOP 如果是 SHUTDOWN，那么执行完 advanceRunState 方法后 ctl 的值>=0，即>=SHUTDOWN。假如当前线程数是 3，那么 ctl 就是 3 如果是 STOP，那么执行完 advanceRunState 方法后 ctl 的值>=536870912，即>=STOP。假如当前线程数是 3，那么 ctl 就是 536870912+3
所以，这也证实了线程池的状态是一个范围，而不是一个值，这个范围正如文档开头处所述
private void advanceRunState(int targetState) { for (;;) { int c = ctl.get(); if (runStateAtLeast(c, targetState) || ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c)))) break; }}
复制代码
interruptIdleWorkers
方法很明确，就是将 workers 对应的线程中断。从方法的名称就可以知道功能是对空闲的线程中断。那怎么知道哪些 work 的线程是空闲的呢
private void interruptIdleWorkers() { interruptIdleWorkers(false);}
private void interruptIdleWorkers(boolean onlyOne) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (Worker w : workers) { Thread t = w.thread; if (!t.isInterrupted() && w.tryLock()) { try { t.interrupt(); } catch (SecurityException ignore) { } finally { w.unlock(); } } if (onlyOne) break; } } finally { mainLock.unlock(); }}
复制代码
注意这点：w.tryLock()，为啥要试图加锁呢。这时候就要看看 runWorker 方法了，runWorker 执行时是要对 worker 加锁的(即调用 lock)。 所有工作中的线程都需要 lock 加锁(state 从 0 变为 1)，所以在这里通过 Worker.tryLock()来判断被检查的工作线程是否是空闲状态(试图将 state 从 0 变为 1)，空闲就可以发送 interrupt()命令。
所以，逻辑上看，w.lock => state 从 0 变为 1 => Worker.tryLock() 试图将 state 从 0 变为 1，结果必然是 false；结果上看，worker 加锁了，就是工作状态，即不是空闲状态，就不能中断了
tryTerminate
final void tryTerminate() { for (;;) { int c = ctl.get(); // 线程池为下面三种情况，直接return // 1.线程池为RUNNING状态，线程池还在运行中，不能终止 // 2.线程池为TIDYING或TERMINATED，因为线程池已经终止了，不用再终止了 // 3.线程池为SHUTDOWN状态 & 线程池队列不为空，队列里有任务，不能终止 if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) return; // 代码走到这，说明此时线程池是STOP状态或(SHUTDOWN状态且线程池队列是空)， 线程池里还有线程 if (workerCountOf(c) != 0) { // Eligible to terminate //这时候可能只有一个空闲线程了，它是在getTask方法中执行workQueue.take()了的线程，此线程属于空闲线程(在w.lock()外)，它正在阻塞着等待着线程来呢。如果不执行中断会一直阻塞。你可能会说，在前面执行interruptIdleWorkers(false)方法时，会中断所有的空闲线程，这里重复执行了吧？试想下如果在执行interruptIdleWorkers(false)时恰好有个工作线程没有空闲，你刚执行完interruptIdleWorkers(false)，那个线程就回到while里去调用了getTask方法，这时workQueue中没有任务了，就会调用workQueue.take()一直阻塞。所以每次在工作线程结束时调用tryTerminate方法来尝试中断那个空闲工作线程，避免在队列为空时取任务一直阻塞的情况 interruptIdleWorkers(ONLY_ONE); return; }
final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { // 将线程池状态设置为TIDYING if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { try { terminated(); } finally { // 执行terminated后，将线程池状态设置为TERMINATED，线程池结束 ctl.set(ctlOf(TERMINATED, 0)); // 通知awaitTermination方法，线程池结束 termination.signalAll(); } return; } } finally { mainLock.unlock(); } // else retry on failed CAS }}
复制代码
shutdownNow
调用 shutdownNow()会进入 STOP 状态。在 STOP 状态下线程池既不接受新的任务，也不处理已经在队列中的任务。对于还在执行任务的工作线程，线程池会发起中断请求来中断正在执行的任务，同时会清空任务队列中还未被执行的任务。
public List<Runnable> shutdownNow() { List<Runnable> tasks; final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(STOP); interruptWorkers(); tasks = drainQueue(); } finally { mainLock.unlock(); } tryTerminate(); return tasks;}
复制代码
shutdownNow 方法核心由四部分组成：
advanceRunState(STOP)：改线程池状态为 STOP，与 advanceRunState(SHUTDOWN)逻辑相同
interruptWorkers()：中断线程池中所有线程，这个与 interruptIdleWorkers 的区别细细体会，这个方法中断所有已经启动的工作线程，即进行中的任务(执行了 w.lock，但还没执行 w.unlock)，这些线程中断可能成功也可能不成功
tryTerminate()：前面已说完
drainQueue()：从任务队列中取出所有未被执行的任务，未被执行的任务列表会被作为返回值返回给应用程序
interruptWorkers
// Interrupts all threads, even if activeprivate void interruptWorkers() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (Worker w : workers) w.interruptIfStarted(); } finally { mainLock.unlock(); }}void interruptIfStarted() { Thread t; if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) { try { t.interrupt(); } catch (SecurityException ignore) { } }}
复制代码
有个疑问：interruptWorkers 是中断线程池中所有的线程(空闲的和执行中的总和)，但 interruptIfStarted()方法只是中断执行中的线程。
如果你有这个疑惑的话，咱们一起看下 getState() >= 0 这个判断，我们看下 runWorker 方法，先执行了 w.unlock()，再执行 w.lock()，在执行 w.unlock()，unlock 是把 state 设置为 0，lock 把 state 设置为 1，又只要执行了 runWorker，那么 state 的值就是>=等于 0 的了，所以不管空闲与否，state 总是>=0，所以 interruptWorkers 方法这时候执行 interruptIfStarted 方法，中断的就是所有的线程
drainQueue
将 workerQueue 队列里的 worker 返回
private List<Runnable> drainQueue() { BlockingQueue<Runnable> q = workQueue; ArrayList<Runnable> taskList = new ArrayList<Runnable>(); q.drainTo(taskList); if (!q.isEmpty()) { for (Runnable r : q.toArray(new Runnable[0])) { if (q.remove(r)) taskList.add(r); } } return taskList;}
复制代码
问答
1、execute 方法里为啥要用 workQueue.offer(command)这个非阻塞方法呢，而不用 put 等阻塞方法呢？
因为 execute 方法是运行在 main 线程里的，如果使用阻塞方法，那么后面的任务就无法添加到线程池了
2、线程池收到 Runnable 任务紧就 start 执行了，为什么还要将任务放入集合（workers.add(w)）呢? workers 集合存在的意义是什么呢？
放入 workers 是为了保存当时的 thread 和 worker，不然后面怎么对 worker 和 thread 进行加锁和中断啊，addWorker 和 runWorker 本来就是并行的关系，还要时刻监视着 shutdown，shutdownNow，terminate 之类的动作
3、workers 与 workerQueue 与 ctl 的关系
workers 的 size 应该=ctl.get；workerQueue 与 ctl 没有关系
4、getTask 方法中为啥使用 workQueue.poll(num, timeUnit) 和 take()方法，为啥不使用非阻塞方法呢？
getTask 里有一个 for 自旋，一直找任务执行，如果不使用阻塞方法，那么 for 自旋将一直占着 cpu，这个原理和 synchronized 的升级原理是一样的
5、线程池里存放的是线程吗？
不是，是 Worker，Worker 是线程池中的线程和任务 task 之间的纽带
6、线程池使用了两个锁 lock，worker 使用一个，reentrantLock 使用一个，作用分别是什么？
worker 的 lock 是属于 worker 的，是为了区分线程是否为空闲还是运行中 reentrantLock mainLock 是属于线程池的，是为了实现线程池中各方法之间保持不竞争的
7、线程池里怎么区分空闲线程和执行中线程
worker 的 thread 是否被 lock
两个发散性的问题：
8、线程池中如何使用 ThreadLocal
9、ThreadPoolExecutor 运行在多线程环境中会怎样的
小结
对 ThreadPoolExecutor 的理解每次都会有新的收获，看似不经意的一行代码，一个判断，实践懂了之后都感叹和震撼作者的编程能力，每次领悟之后，都感觉作者的实现技巧都开启了我以前没见过的窗。
作者：skyler_划枫悄敲
链接：https://juejin.cn/post/7169216470512041992
来源：稀土掘金
评论