本文共 8563 字，大约阅读时间需要 28 分钟。
线程池的工作原理，以及拒绝策略，大家都很熟悉，下面主要讲一下线程池shutdown的原理，以及一些不常用操作的原理。
public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(SHUTDOWN); interruptIdleWorkers(); onShutdown(); // hook for ScheduledThreadPoolExecutor } finally { mainLock.unlock(); } tryTerminate();}复制代码 启动有序关闭，在该关闭中执行先前提交的任务，但不接受任何新任务。如果已关闭，则调用不会产生任何其他影响。此方法不等待先前提交的任务完成执行。使用awaitTermination可以做到这一点。
private void advanceRunState(int targetState) { for (;;) { int c = ctl.get(); if (runStateAtLeast(c, targetState) || ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c)))) break; }}复制代码 将runState转换为给定状态，或者已经存在的状态比给定状态大时将直接返回。 循环使用CAS设置状态，设置成功返回。
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(); }}复制代码 因为work每次执行任务的时候都会先lock，完成任务后unlock， 如果tryLock可以成功说明work当前没有在执行任务。使用interrupt中断空闲的work线程。
final void tryTerminate() { for (;;) { int c = ctl.get(); if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty())) return; if (workerCountOf(c) != 0) { // Eligible to terminate interruptIdleWorkers(ONLY_ONE); return; } final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { try { terminated(); } finally { ctl.set(ctlOf(TERMINATED, 0)); termination.signalAll(); } return; } } finally { mainLock.unlock(); } // else retry on failed CAS }}复制代码 public ListshutdownNow() { List tasks; final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(STOP); interruptWorkers(); tasks = drainQueue(); } finally { mainLock.unlock(); } tryTerminate(); return tasks;}复制代码
尝试停止所有正在执行的任务，暂停正在等待的任务的处理，并返回正在等待执行的任务的列表。从此方法返回后，这些任务将从任务队列中耗尽（删除）。此方法不等待主动执行的任务终止。除了尽最大努力尝试停止处理正在执行的任务之外，没有任何保证。此实现通过中断取消任务，因此任何无法响应中断的任务都可能永远不会终止。
private void interruptWorkers() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (Worker w : workers) w.interruptIfStarted(); } finally { mainLock.unlock(); }}复制代码 中断所有线程，即使处于活动状态也是如此。
private ListdrainQueue() { BlockingQueue q = workQueue; ArrayList taskList = new ArrayList (); q.drainTo(taskList); if (!q.isEmpty()) { for (Runnable r : q.toArray(new Runnable[0])) { if (q.remove(r)) taskList.add(r); } } return taskList;}复制代码
使用drainTo方法将任务队列写入新列表。但是，如果队列是DelayQueue或其他类型的队列，但poll或drainTo可能无法删除某些元素，则将它们逐个删除。
Worker主要维护运行任务线程的中断控制状态，以及其他次要簿记。此类扩展了AbstractQueuedSynchronizer，以简化获取和释放围绕每个任务执行的锁。我们实现了一个简单的非可重入互斥锁，而不是使用ReentrantLock，因为我们不希望辅助任务在调用诸如setCorePoolSize之类的池控制方法时能够重新获取该锁。另外，为了抑制直到线程真正开始运行任务之前的中断，我们将锁定状态初始化为负值，并在启动时将其清除（在runWorker中）。
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); Runnable task = w.firstTask; w.firstTask = null; w.unlock(); // allow interrupts boolean completedAbruptly = true; try { while (task != null || (task = getTask()) != null) { w.lock(); // If pool is stopping, ensure thread is interrupted; // if not, ensure thread is not interrupted. This // requires a recheck in second case to deal with // shutdownNow race while clearing interrupt 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) { thrown = x; throw new Error(x); } finally { afterExecute(task, thrown); } } finally { task = null; w.completedTasks++; w.unlock(); } } completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); }}复制代码 Work反复从队列中获取任务并执行它们，同时解决许多问题：
private void processWorkerExit(Worker w, boolean completedAbruptly) { if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted decrementWorkerCount(); final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { completedTaskCount += w.completedTasks; workers.remove(w); } finally { mainLock.unlock(); } tryTerminate(); // shutdown状态时，每个工作线程完成工作后，终止线程池 int c = ctl.get(); if (runStateLessThan(c, STOP)) { if (!completedAbruptly) { int min = allowCoreThreadTimeOut ? 0 : corePoolSize; if (min == 0 && ! workQueue.isEmpty()) min = 1; if (workerCountOf(c) >= min) return; // replacement not needed } addWorker(null, false); // 工作线程执行任务异常退出时，重新启动一个工作线程来完成任务 }}复制代码 线程池的控制状态ctl是一个atomic integer。表示workCount和runState两个字段。
workerCount指示有效线程数。int的后29位表示有效线程数。
runState，指示是否正在运行，正在关闭等。int的前三位表示线程池的状态。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));private static int runStateOf(int c) { return c & ~CAPACITY; }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;}private static final int COUNT_BITS = Integer.SIZE - 3; // 29，11101private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 29位，全是1，值 536870911private static final int RUNNING = -1 << COUNT_BITS; // 32位，前三位是1， 值 -536870912private static final int SHUTDOWN = 0 << COUNT_BITS; // 值 0private static final int STOP = 1 << COUNT_BITS; // 30位，第一位是1，值 536870912private static final int TIDYING = 2 << COUNT_BITS; // 31位，第一位是1，值 1073741824private static final int TERMINATED = 3 << COUNT_BITS; // 31位，前两位是1， 值 1610612736-1 // 11111111111111111111111111111111, 32位0 // 01 // 12 // 103 // 11~CAPACITY // 32位，前三位是1，11100000000000000000000000000000，值-536870912
转载地址：http://vyfvi.baihongyu.com/