【JUC源码解析】ThreadPoolExecutor

简介

ThreadPoolExecutor，线程池的基石。

概述

线程池，除了用HashSet承载一组线程做任务以外，还用BlockingQueue承载一组任务。corePoolSize和maximumPoolSize，分别表示线程弛里存活的最小和最大线程数目，keepAliveTime表示不干活的线程的存活时间。当过来一个任务时，如果线程池里的线程数目小于corePoolSize，那么直接创建一个线程去处理它；如果线程数目大于等corePoolSize并且小于maximumPoolSize，那么，将这个任务放进任务队列里；如果任务队列已满，则继续创建线程处理该任务；如果线程弛数目等于maximumPoolSize，此时任务队列肯定已经满了，那么采取饱和策略。如果线程池里的线程空闲时间达到keepAliveTime，并且数量大于corePoolSize，此刻任务队列肯定是空的，那么销毁该线程。

线程池的控制状态

 // 线程池的控制状态，高3位表示运行状态，低29位表示线程的数量
     private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

     private static final int COUNT_BITS = Integer.SIZE - 3; // 29位的偏移量
     private static final int CAPACITY = (1 << COUNT_BITS) - 1; // 最大容量

     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; // 整理中，所有的任务都已经停止，线程数为0，并调用terminate（钩子）方法
     private static final int TERMINATED = 3 << COUNT_BITS; // 终止，terminate方法运行完毕

     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;
     }

状态转换关系

RUNNING -> SHUTDOWN                     // shutdown()方法被调用
(RUNNING or SHUTDOWN) -> STOP    // shutdownNow()方法被调用
SHUTDOWN -> TIDYING                       // 线程池和任务队列都为空
STOP -> TIDYING                                   // 线程池为空
TIDYING -> TERMINATED                     // terminated()方法运行完毕

属性

     private final BlockingQueue<Runnable> workQueue; // 任务队列
     private final ReentrantLock mainLock = new ReentrantLock(); // 可重入锁
     private final HashSet<Worker> workers = new HashSet<Worker>(); // 线程集合
     private final Condition termination = mainLock.newCondition(); // 终止条件
     private int largestPoolSize; // 最大线程池容量
     private long completedTaskCount; // 已完成任务数量
     private volatile ThreadFactory threadFactory; // 线程工厂
     private volatile RejectedExecutionHandler handler; // 饱和策略
     private volatile long keepAliveTime; // 线程等待时间
     private volatile boolean allowCoreThreadTimeOut; // 是否允许核心线程超时
     private volatile int corePoolSize; // 核心线程池大小
     private volatile int maximumPoolSize; // 最大线程池大小
     private static final RejectedExecutionHandler defaultHandler = new AbortPolicy(); // 默认饱和策略

Worker

继承关系

private final class Worker extends AbstractQueuedSynchronizer implements Runnable {}

属性

         final Thread thread; // 承载的线程
         Runnable firstTask; // 首任务
         volatile long completedTasks; // 已完成任务数量

构造方法

         Worker(Runnable firstTask) {
             setState(-1); // 执行任务之前，禁止中断
             this.firstTask = firstTask; // 初始化首任务
             this.thread = getThreadFactory().newThread(this);  // 初始化线程
         }

主要方法

         public void run() { // 重写Runnable的run方法
             runWorker(this);
         }

         protected boolean isHeldExclusively() { // 是否被独占，0否，1是
             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;
             if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {// 1. 状态大于等于0 2.线程不为空 3该线程没被中断
                 try {
                     t.interrupt(); // 中断
                 } catch (SecurityException ignore) {
                 }
             }
         }
     }

execute(Runnable)

     public void execute(Runnable command) {
         if (command == null)
             throw new NullPointerException();
         int c = ctl.get(); // 获取线程池的控制状态
         if (workerCountOf(c) < corePoolSize) { // 1. worker数量小于corePoolSize,
                                                 // 创建线程
             if (addWorker(command, true))
                 return; // 成功返回
             c = ctl.get(); // 失败，再次获取控制状态（调用addWorker方法，该状态更改过）
         }
         if (isRunning(c) && workQueue.offer(command)) {// 2.查看线程池是否处于运行状态，是则说明worker数量不满足条件1，因此任务入队；
                                                        // 否则，线程池处于非运行状态，进入3(最后会reject);要么入队失败，也进入3(也许会成功)
             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.两次使用之间，显式更新了变量，此时要重新获取，以便得到最新值。2.根据此变量的值，执行某项策略，需要回过头来再次检查，如果改变，则回滚。（乐观锁）

addWorker(Runnable, boolean)

     private boolean addWorker(Runnable firstTask, boolean core) {
         retry: for (;;) { // A. runState变化，重试
             int c = ctl.get(); // ctl
             int rs = runStateOf(c); // runState
             // 等价于
             // if (!(rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty())))
             //     return false;
             // 也即是
             // if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
             // 接着往下走：a. rs == RUNNING; 或者，b. rs == SHUTDOWN, 并且，firstTask == null, 再并且工作队列不为空
             // a. 不必解释
             // b. rs == SHUTDOWN时，此时，不再接受新任务，但是，工作队列里的任务还是要处理的，若是线程池里没有线程了，还是需要新增线程处理这些任务的
             // 如何与由新任务发起的创建线程做区分呢？答案就是firstTask是否为null，不为null就是新任务发起的
             if (rs >= SHUTDOWN && !(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
                 return false;

             for (;;) { // B.workerCount变化，重试
                 int wc = workerCountOf(c);
                 if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) // 校验workerCount
                     return false;
                 if (compareAndIncrementWorkerCount(c)) // 竞态点，可能失败：1.runState变化  -> A 2.workerCount变化  -> B
                     break retry;
                 c = ctl.get(); // 重新读取ctl
                 if (runStateOf(c) != rs) // 如果runState发生变化，转向A；否则，转向B
                     continue retry;
             }
         }

         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操作，加锁
                 try {
                     int rs = runStateOf(ctl.get()); // 再次读取runState, 因为在此过程中，可能会有别的线程操作此变量
                     if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { // C 第二次校验runState，与上面不同的是，这次没有校验工作队列是否为空
                         if (t.isAlive()) // 检验该线程是否已经启动，正常没有启动
                             throw new IllegalThreadStateException();
                         workers.add(w); // 添加到线程池里
                         int s = workers.size(); // 工作者的实际数量
                         if (s > largestPoolSize)
                             largestPoolSize = s; // 记录工作者最大数量
                         workerAdded = true; // 添加成功
                     }
                 } finally {
                     mainLock.unlock(); // 解锁，别的线程可以操作workers了
                 }
                 if (workerAdded) { // 如果添加成功
                     t.start(); // 启动线程
                     workerStarted = true; // 线程启动成功
                 }
             }
         } finally {
             if (!workerStarted) // 如果线程启动失败
                 addWorkerFailed(w); // 回滚
         }
         return workerStarted; // 返回结果
     }

代码注释C处，第二次校验runState时，为什么没有校验工作队列workQueue了呢？

考虑这样一种场景

1. 线程池里的线程没有空闲的，都在工作，执行任务。
2. 其中一个线程由于某种原因，跳出了while 循环。也许是某一时刻，workQueue里的任务被其他线程取空了，到此线程时，阻塞在workQueue.take()方法上了，而后又刚好遇到中断（各种原因），于是返回null并跳出了循环。
3. 后来，workQueue又持续添加了新的任务，其他线程接着工作，中间没收到打扰。
4. 接着，runState变为SHUTDOWN或者在第8步之后变为SHUTDOWN,此时还是RUNNING ，那个跳出循环的线程，我们暂且称为JUMP线程吧，走到addWork(null,false)方法。
5. 在双重for循环检测时，恰巧满足条件

   if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))

   于是，会继续往下执行，此时，其他的线程仍在紧锣密鼓地工作。

6. 注意，JUMP线程已经执行过tryTerminate()方法了，并且此线程马上就消亡了，调用addWork(null,false)方法也是为了创建新的线程替代它的。
7. JUMP线程走到创建工作者那里时，也就是再次（第二次）检验runState的地方。
8. 恰巧这时，workQueue被其他线程取空了，更巧的是，所有其他的线程都阻塞在了workQueue.take()方法上，从getTask() 方法逻辑可知，这是发生在runState变为SHUTDOWN之前，不然后面的线程会检查runState状态，直接return null了。
9. 好了，时间停在了这一刻：JUMP线程准备第二次校验runState，其他线程阻塞在workQueue.take()方法上；不过，在runState变为SHUTDOWN时，也就是调用shutdown()方法，会调用tryTerminate()方法。
10. 在tryTerminate()方法里，检查runState为SHUTDOWN，workQueue为空，但threadPool不为空，于是会走interruptIdleWorkers(ONLY_ONE)方法，随意中断一个空闲线程，注意，这里没有走到terminated()方法。
11. 一个阻塞在workQueue.take()方法上的线程被唤醒，并跳出while循环，runWorker(Worker)里的逻辑，然后调用tryTerminate()方法，同步骤10，接着调用addWorker(null, false)，当然在方法开始处，双重for循环那里就返回了，因为不满足条件，此刻workQueue已经为空。
12. 就这样，10->11->10->11，一个接一个地调用，中断后面的阻塞着的线程并传播下去，直到最后一个，调用tryTerminate()方法，由于workCount不为0.，因为JUMP线程在双重for循环那里通过了检查，使得workCount加1了，于是，这最后一个被中断叫醒的线程也是走的第10步，只是没有空闲线程可以中断了。
13. 最后，JUMP在第二次检查runState时，不应该再检查workQueue是否为空了，如果检查，由于workQueue为空，那么将会回滚，JUMP线程没有加入到threadPool里面去，那么便没有线程调用最终的terminated()方法了。
14. 由于都是异步的，以上步骤并不具有严格的时间顺序。
15. 第13步有误，即便由于检查了workQueue为空而回滚，也会调用terminated()方法的，因为回滚的时候会调用addWorkerFailed(Worker)方法，这个方法会调用tryTerminate()方法，因为此时满足了条件继而terminated()方法。
16. 但是不检查workQueue是否为空也没错，因为两方面费的力气差不多，因此，只在必要的时候检查workQueue，就像第一次那样。

addWorkerFailed(Worker)

     private void addWorkerFailed(Worker w) {
         final ReentrantLock mainLock = this.mainLock;
         mainLock.lock();
         try {
             if (w != null)
                 workers.remove(w);
             decrementWorkerCount();
             tryTerminate();
         } finally {
             mainLock.unlock();
         }
     }

runWorker(Worker w)

     final void runWorker(Worker w) {
         Thread wt = Thread.currentThread(); // 当前线程
         Runnable task = w.firstTask; // 首任务
         w.firstTask = null; // 置位
         w.unlock(); // 允许中断（interruptIdleWorkers()方法），因为即便不unlock()，也阻止不了interruptWorkers()方法中断此线程
         boolean completedAbruptly = true; // 是否是突然完成，即异常情况
         try {
             while (task != null || (task = getTask()) != null) { // 如果首任务不为空，执行首任务；否则，从任务队列里取任务
                 w.lock(); // 加锁，防止中断（interruptIdleWorkers()方法）
                 // 如果线程池停止了，中断此线程，否则，复位可能的中断，若此线程中断过，需要再次检查线程池是否停止
                 // 有可能这边刚把中断复位，那边就把线程池停止了
                 // ！第一次检查线程池是否停止，是因为，线程池停止了，应该直接中断此线程
                 // ！第二次检查线程池是否停止，是因为，如果线程被中断了，刚好把它复位，很有可能是前一瞬间线程池停止导致的中断，所以要再次确认线程池的状态
                 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(); // 释放锁，允许中断（interruptIdleWorkers()方法）
                 }
             }
             completedAbruptly = false; // 平滑结束
         } finally {
             processWorkerExit(w, completedAbruptly); // 处理后续工作
         }
     }

getTask()

     private Runnable getTask() {
         boolean timedOut = false; // 记录上次workQueue.poll是否超时

         for (;;) { // 循环
             int c = ctl.get(); // 得到ctl
             int rs = runStateOf(c); // 得到runState

             // 等价于，if !(rs < SHUTDOWN || (rs < STOP && !workQueue.isEmpty()))
             // 即是，if !(rs == RUNNING || (rs == SHUTDOWN && !workQueue.isEmpty()))
             if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                 decrementWorkerCount(); // workerCount - 1
                 return null; // 返回null
             }

             int wc = workerCountOf(c); // 得到workerCount

             // 是否允许超时
             boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

             // 1. workerCount > maximumPoolSize
             // 2. timed为真，并且timeOut也为真，即上次已超时，而且，此刻workerCount大于1，或者workQueue为空
             if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) {
                 if (compareAndDecrementWorkerCount(c)) // workerCount减1
                     return null;
                 continue; // 否则，重试
             }

             try {
                 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); // 允许超时，调用poll()方法，否则take()方法
                 if (r != null)
                     return r; // 不为空，返回
                 timedOut = true; // 否则，继续
             } catch (InterruptedException retry) {
                 timedOut = false; // 中断，清除超时标记
             }
         }

processWorkerExit(Worker, boolean)

     private void processWorkerExit(Worker w, boolean completedAbruptly) {
         if (completedAbruptly) // 如果是异常结束，需要调整workCount(-1)，因为正常结束的,会在getTask()方法里调用decrementWorkerCount()方法
             decrementWorkerCount();
         final ReentrantLock mainLock = this.mainLock; // 可重入锁，因为要对works操作
         mainLock.lock(); // 加锁
         try {
             completedTaskCount += w.completedTasks; // 添加当前线程完成的任务数量加到总的完成任务数量
             workers.remove(w); // 从线程池中移除该线程
         } finally {
             mainLock.unlock(); // 释放锁
         }

         tryTerminate(); // 调用tryTerminate()方法，看是否满足结束条件

         int c = ctl.get(); // 获得ctl
         if (runStateLessThan(c, STOP)) { // 线程池没有停止
             if (!completedAbruptly) { // 该线程平滑结束
                 int min = allowCoreThreadTimeOut ? 0 : corePoolSize; // 得出最小线程数
                 if (min == 0 && !workQueue.isEmpty()) // 最少保留1个
                     min = 1;
                 if (workerCountOf(c) >= min) // 如果不小于最小线程数，不必再添加
                     return;
             }
             addWorker(null, false); // 如果是异常结束，则说明任务队列里应该还有任务，那么直接添加新的线程替换它
         }
     }

shutdown()

     public void shutdown() {
         final ReentrantLock mainLock = this.mainLock;
         mainLock.lock(); // 获得锁
         try {
             checkShutdownAccess(); // 检查权限
             advanceRunState(SHUTDOWN); // 设置状态
             interruptIdleWorkers(); // 中断空闲线程
             onShutdown(); // 钩子 ScheduledThreadPoolExecutor
         } finally {
             mainLock.unlock(); // 释放锁
         }
         tryTerminate(); // 尝试终止线程池
     }

shutdownNow()

     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; // 返回任务列表
     }

interruptIdleWorkers()

     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(); // 释放可重入锁
         }
     }

interruptWorkers()

     private void interruptWorkers() {
         final ReentrantLock mainLock = this.mainLock; // 获得可重入锁
         mainLock.lock(); // 加锁
         try {
             for (Worker w : workers)
                 w.interruptIfStarted(); // 只要线程已经启动，就中断它
         } finally {
             mainLock.unlock(); // 释放锁
         }
     }

tryTerminate()

     final void tryTerminate() {
         for (;;) {
             int c = ctl.get(); // 获得ctl
             // 1. 线程池正在运行
             // 2. 线程池已经结束或正在整理
             // 3. 线程池已经SHUTDOWN，但是workQueue不为空
             if (isRunning(c) || runStateAtLeast(c, TIDYING) || (runStateOf(c) == SHUTDOWN && !workQueue.isEmpty()))
                 return;
             // workerCount不等于0，只中断一个空闲线程，保证中断传播下去
             if (workerCountOf(c) != 0) {
                 interruptIdleWorkers(ONLY_ONE);
                 return;
             }

             final ReentrantLock mainLock = this.mainLock; // 可重入锁
             mainLock.lock(); // 加锁
             try {
                 if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { // 设置状态为TIDYING
                     try {
                         terminated(); // 调用terminated()方法，钩子，用户实现
                     } finally {
                         ctl.set(ctlOf(TERMINATED, 0)); // 设置状态为TERMINATED
                         termination.signalAll(); // 通知信号
                     }
                     return;
                 }
             } finally {
                 mainLock.unlock(); // 解锁
             }
         }
     }

行文至此结束。

尊重他人的劳动，转载请注明出处：http://www.cnblogs.com/aniao/p/aniao_tpe.html