本文源码解析基于JDK1.8 本人愚见，若有错误，请指正，谢谢
ThreadPoolExecutor是Java中的线程池的核心类。用Executors创建的线程池本质也是用的该类，定时任务用到的ScheduleThreadPoolExecutor是继承于此类。
ThreadPoolExecutor定义了一个原子类对象ctl，用来保存线程池的状态和线程池的线程数量。Integer数据类型长度有32位，ctl将高位3位保存状态标志，低位29位保存worker数量。初始化后，默认状态是RUNNING，线程数量是0。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; private static final int CAPACITY = (1 << COUNT_BITS) - 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;COUNT_BITS是worker数量所占用的位数，此处为29。 CAPACITY 是worker的最大数量， 229 -1=536870911，二进制表示为00011111111111111111111111111111。 线程池共有5个状态：状态由ctl的高三位保存。
状态状态位描述RUNNING111线程池初始化后的默认状态，接收并处理任务SHUTDOWN000调用shutdown()方法后的状态，拒绝接收任务，但会处理队列中的任务STOP001调用shutdownNow()方法后的状态，拒绝接收任务，同时中断正在运行的任务TIDYING010工作队列为空，同时线程数量为0时的状态，有个terminated()的hookTERMINATED011线程池停止ThreadPoolExecutor共有4个构造器，最根本的是参数最多的那个。此构造器参数有7位，分别是:
参数名描述corePoolSize核心线程池大小，核心线程是指在空闲情况下依然能存活的线程，除非allowCoreThreadTimeOut()设置为truemaximumPoolSize线程池持有的最大线程数量keepAliveTime线程存活时间，当线程数量大于corePoolSize时，空闲线程在关闭前等待task的最大时间unit线程存活时间单位，keepAliveTime的单位workQueue用来暂时保存任务的队列threadFactory线程工厂，executor创建thread的工厂handler当ThreadPoolExecutor关闭或ThreadPoolExecutor已经饱和时，execute()调用的饱和策略源码如下：
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; }类中还有个变量allowCoreThreadTimeOut，用来设置coreThread是否可以在空闲时超时关闭，需要用allowCoreThreadTimeOut方法来设置。
public void allowCoreThreadTimeOut(boolean value) { if (value && keepAliveTime <= 0) throw new IllegalArgumentException("Core threads must have nonzero keep alive times"); if (value != allowCoreThreadTimeOut) { allowCoreThreadTimeOut = value; if (value) interruptIdleWorkers(); } }ThreadPoolExecutor可以使用submit()或者execute()方法提交任务，区别在于submit()可以提交Callable的任务，就是带有返回值的任务，但是callable对象会被包装成runnable对象，还是调用execute()。
public void execute(Runnable command) { if (command == null) throw new NullPointerException(); int c = ctl.get(); if (workerCountOf(c) < corePoolSize) { 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); }一个task提交后，线程池的处理流程如下： 1. 核心线程池还未满，则创建一个新的核心线程执行任务。新建核心线程成功，方法结束返回。如果失败，则获取新的ctl值，进入步骤2。 2. 判断线程池是在运行且成功添加任务到工作队列中，则获取新的ctl，再次判断状态。如果状态为非运行，且成功从工作队列中移出任务，则拒绝任务。如果是运行状态或者移除任务失败，移出任务失败说明此任务可能被执行或者遇到shutdownNow()方法，任务被移除队列，运行状态的话，这里判断线程数量为0(不理解)，添加一个非核心线程。 3. 如果任务无法加到工作队列中，或者线程池不在运行状态：如果是线程池关闭，则不考虑后续；如果是工作队列已满，则添加非核心线程处理任务。如果线程池已满，无法添加非核心线程，则拒绝任务。
工作线程Worker是ThreadPoolExecutor的内部类，继承了AbstractQueuedSynchronizer，封装了线程和任务，并且维护了一个state状态。state在初始化时是-1，防止在工作线程还未运行时，就被interrupts。在开始运行时，设置为0。并且在执行任务开始前后分别设置为1，0，等待task时的state是0，目的是将正在运行task和等待task的worker区别开，以便在修改线程池参数或者shutdown时可以interrupt等待任务的worker。
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { final Thread thread; volatile long completedTasks; Worker(Runnable firstTask) { setState(-1); // 设置state为-1，防止线程还未start，就被interrupt this.firstTask = firstTask; this.thread = getThreadFactory().newThread(this); } public void run() { runWorker(this); } protected boolean isHeldExclusively() { return getState() != 0; } protected boolean tryAcquire(int unused) { if (compareAndSetState(0, 1)) { setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } protected boolean tryRelease(int unused) { setExclusiveOwnerThread(null); setState(0); return true; } public void lock() { acquire(1); } public boolean tryLock() { return tryAcquire(1); } public void unlock() { release(1); } public boolean isLocked() { return isHeldExclusively(); } void interruptIfStarted() { Thread t; // 由shutdownNow()调用 if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) { try { t.interrupt(); } catch (SecurityException ignore) { } } } }addWorker()方法用来添加工作线程。
private boolean addWorker(Runnable firstTask, boolean core) { retry: for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) // 上述的rs >= SHUTDOWN && !(rs==shutdown && firstTask==null && !workQueue.isEmpty())可以推导为 // rs >= SHUTDOWN && (rs!=shutdown || firstTask!=null || workQueue.isEmpty()) // 也就是： // 线程池在running状态，添加工作线程 // 线程池在shutdown状态下，firstTask不为空，不添加工作线程，此处返回false，应该是要reject。 // 线程池在shutdown状态下，firstTask为空，workQueue为空时，不添加工作线程，换句话说workQueue不为空时，可以添加线程加快处理速度。 // 线程池在stop,tidying,terminated状态下，不添加工作线程 return false; for (;;) { int wc = workerCountOf(c); // 当前线程池的工作线程数量达到最大数量，或者核心线程数量或最大线程数量达到上限，返回false。 if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; // 原子类的CAS操作 // 工作线程数+1，如果状态改变或者工作线程数变化，则CAS更新失败 if (compareAndIncrementWorkerCount(c)) break retry; c = ctl.get(); // Re-read ctl // 如果状态不变，就自循环增加wc，如果状态变了，就需要重新判断状态。 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 { // 初始化新的worker，用threadFactory创建新的线程 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()); if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) throw new IllegalThreadStateException(); workers.add(w); // 更新同一时间最多用到多少个线程largestPoolSize 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; }其中的run()方法调用runWorker()方法就是执行task的方法了。
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(); // 如果线程池在STOP及之后状态，而且线程不是中断的，则中断线程 // 因为有可能调用shutdownNow()，所以这里有第二次检查，也是检查线程池状态，Thread.interrupted()是用来判断线程是否中断，同时清除中断标志。 if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { beforeExecute(wt, task); // hook 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); // hook } } finally { task = null; w.completedTasks++; w.unlock(); } } // 如果task为null，或者task顺利执行完，设置为false；如果task报错，为true completedAbruptly = false; } finally { processWorkerExit(w, completedAbruptly); } }worker有几种结束的情况： 1. 线程池调用shutdownNow()，中断线程退出。这种情况就不会新建线程。 2. 任务报错退出，如果线程池在RUNNING和shutdown状态，会新建一个线程继续处理任务。 3. 正常运行结束，因为while循环会一直拿task，所以正常结束意味着没任务或者STOP状态不给任务。如果当前线程数能满足要求（核心线程数或者1个线程），则不创建新线程。 worker结束后，从workers里移除，并尝试关闭线程池。
//worker最后的时光 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(); 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); } }getTask()用于获取任务
private Runnable getTask() { boolean timedOut = false; // Did the last poll() time out? for (;;) { int c = ctl.get(); int rs = runStateOf(c); // Check if queue empty only if necessary. if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } int wc = workerCountOf(c); // Are workers subject to culling? boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) return null; continue; } try { Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }getTask()是获取任务的方法，线程空闲时间超时也是这里控制的。有几种情况是拿不到task的： 1. 线程池是stop状态 2. 线程池是shutdown状态，并且工作队列为null。 3. 线程数大于maximumPoolSize，在变更maximumPoolSize参数后，有可能发生。 4. 线程数大于corePoolSize，并且超时 5. 在allowCoreThreadTimeOut 为true时，线程数大于1，并且获取task超时。 6. 在allowCoreThreadTimeOut 为true时，工作队列没有task，并且获取task超时。 在拿不到task的情况，会将线程数-1，并且return null。
shutdownNow()用来立刻结束线程池，中断所有线程，并且返回还未执行的任务。 终结的步骤： 1. 检查shutdown的权限，调用其他thread的interrupt方法需要权限。 2. 设置线程池状态为stop，如果线程池状态已经是STOP，TIDYING，TERMINATED，则不更改。 3. 中断所有工作线程。 4. 取出尚未执行的任务作为返回值。 5. 调用tryTerminate结束线程池。
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; }shutdown()方法用来有计划地结束线程池: 1. 首先拒绝接收新任务。 2. 然后检查shutdown权限 3. 设置线程池状态为shutdown 4. 中断所有空闲线程 5. 执行完所有任务后，才真正结束线程池。
public void shutdown() { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { checkShutdownAccess(); advanceRunState(SHUTDOWN); interruptIdleWorkers(); onShutdown(); // hook for ScheduledThreadPoolExecutor } finally { mainLock.unlock(); } tryTerminate(); }tryTerminate()这个方法会真正将线程池设置为terminated状态。 步骤： 1. RUNNING，TIDYING，TERMINATED状态直接返回，shutdown状态下还有任务的情况下，返回 2. 工作线程数量不为0时，中断空闲线程，返回 3. 1和2都不满足的情况下，设置线程池状态为TIDYING 4. 调用terminated()方法，这是个hook，为TIDYING准备的 5. 设置状态为TERMINATED，
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 } }在调用shutdown, shutdownNow后，并不是方法结束，线程池就结束的，所以tryTerminate方法在其他方法中也有调用： 1. addWorkerFailed()，这个方法是在增加工作线程失败时调用 2. processWorkerExit()，工作线程结束时调用 3. shutdown() 4. shutdownNow() 5. remove()，这个方法用来删除任务 6. purge()，这个方法用来移除工作队列中的Callable任务
Executor提供了一个方法awaitTermination，用来判断在指定时间内，线程池有没有关闭。
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException { long nanos = unit.toNanos(timeout); final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { for (;;) { if (runStateAtLeast(ctl.get(), TERMINATED)) return true; if (nanos <= 0) return false; nanos = termination.awaitNanos(nanos); } } finally { mainLock.unlock(); } }在线程池不被引用，而且没有线程时，GC会清理掉这个对象，在清理之前会调用这个方法。
protected void finalize() { shutdown(); }