Java并发编程--ThreadPoolExecutor

概述

　　为什么要使用线程池？　　

　　合理利用线程池能够带来三个好处。第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。——摘自http://www.infoq.com/cn/articles/java-threadPool。

类图

 　　

使用

　　线程池的监控

　　　　可以通过线程池的以下属性监控线程池的当前状态：

　　　　　　getTaskCount()：线程池已经执行的和未执行的任务总数，因为统计的过程中可能会发生变化，该值是个近似值；

　　　　　　getCompletedTaskCount():已完成的任务数量，是个近似值，该值小于等于TaskCount；

　　　　　　getLargestPoolSize()：线程池曾经的最大线程数量，可以通过该值判断线程池是否满过。如该数值等于线程池的最大大小，则表示线程池曾经满过；

　　　　　　getPoolSize()：线程池当前的线程数量；

　　　　　　getActiveCount()：线程池中活动的线程数（正在执行任务），是个近似值。

　　　　还可以通过重写线程池提供的hook方法（beforeExecute、afterExecute和terminated）进行监控，例如监控任务的平均执行时间、最大执行时间和最小执行时间等。

　　　　程序员可以通过重写钩子 hook 方法（如beforeExecute）实现ThreadPoolExecutor的扩展。

　　　　扩展示例：添加了简单的暂停/恢复功能的子类

class PausableThreadPoolExecutor extends ThreadPoolExecutor {
    private boolean isPaused;    //标志是否被暂停
    private ReentrantLock pauseLock = new ReentrantLock();    //访问isPaused时需要加锁，保证线程安全
    private Condition unpaused = pauseLock.newCondition();

    public PausableThreadPoolExecutor(...) { super(...); }
    
    //beforeExecute为ThreadPoolExecutor提供的hood方法
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        pauseLock.lock();
        try {
            while (isPaused) 
                unpaused.await();
        } catch(InterruptedException ie) {
            t.interrupt();
        } finally {
            pauseLock.unlock();
        }
    }
    //暂停
    public void pause() {
        pauseLock.lock();
        try {
            isPaused = true;
        } finally {
            pauseLock.unlock();
        }
    }
    //取消暂停
    public void resume() {
        pauseLock.lock();
        try {
            isPaused = false;
            unpaused.signalAll();
        } finally {
            pauseLock.unlock();
        }
    }
}

实现原理

　　ThreadPoolExecutor源码分析

　　　　域

//ctl是控制线程池状态的一个变量，包含有效的线程数（workerCount）和线程池的运行状态（runState）两部分信息。高3位表示runState，低29位表示workerCount。
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;    //表示workerCount的位数，29位。
private static final int CAPACITY   = (1 << COUNT_BITS) - 1;    //线程数的上限，(2^29)-1，大约5亿

// 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;    //所有的线程都被终止，workerCount为0时会进入该状态.
private static final int TERMINATED =  3 << COUNT_BITS;    //terminated()方法完成后将进入该状态。

　　　　　　以上ThreadPoolExecutor的成员变量表示线程池的状态，状态信息存储在ctl变量中，ctl包含有效线程数（workerCount）和线程池运行状态（runState）两部分信息，ctl的高3位表示runState，低29位表示workerCount。ctl初始值为RUNNING状态且线程数为0。

　　　　　　线程池运行状态的转换如下：

　　　　　　　　1）线程池在RUNNING状态下调用shutdown()方法会进入到SHUTDOWN状态，（finalize()方法也会调用shutdownNow()）。

　　　　　　　　2）在RUNNING和SHUTDOWN状态下调用 shutdownNow() 方法会进入到STOP状态。

　　　　　　　　3）在SHUTDOWN状态下，当阻塞队列为空且线程数为0时进入TIDYING状态；在STOP状态下，当线程数为0时进入TIDYING状态。

　　　　　　　　4）在TIDYING状态，调用terminated()方法完成后进入TERMINATED状态。

 

//阻塞队列
private final BlockingQueue<Runnable> workQueue;
//可重入锁。访问woker线程和相关记录信息时需要获取该锁
private final ReentrantLock mainLock = new ReentrantLock();
//包含全部worker线程集合，Accessed only under mainLock,HashSet是非线程安全的.
private final HashSet<Worker> workers = new HashSet<Worker>();
private final Condition termination = mainLock.newCondition();
//记录最大的线程数量，Accessed only under mainLock.
private int largestPoolSize;
//完成任务的数量，Accessed only under mainLock.
private long completedTaskCount;


//以下所有程序员可以控制的参数都被声明为volatile变量，保证可见性。

//创建线程的工厂
private volatile ThreadFactory threadFactory;
//线程池饱和或关闭时的处理策略（提供了四种饱和策略）
private volatile RejectedExecutionHandler handler;
//超出corePoolSize数量的空闲线程存活时间（allowCoreThreadTimeOut=true时有效）
private volatile long keepAliveTime;
//allowCoreThreadTimeOut=false，线程不会因为空闲时间超过keepAliveTime而被停止
private volatile boolean allowCoreThreadTimeOut;
//核心线程数
private volatile int corePoolSize;
//最大线程数，此变量的最大上限为CAPACITY
private volatile int maximumPoolSize;

　　　　　　一、线程池核心线程数和最大线程数

　　　　　　　　ThreadPoolExecutor 将根据 corePoolSize （核心线程数）和 maximumPoolSize（最大线程数）设置的边界自动调整线程池大小。当新任务在方法 execute(java.lang.Runnable) 中提交时，如果运行的线程少于 corePoolSize，则创建新线程来处理请求，即使其他辅助线程是空闲的。如果运行的线程多于 corePoolSize 而少于 maximumPoolSize，则仅当队列满时才创建新线程。如果设置的 corePoolSize 和 maximumPoolSize 相同，则创建了固定大小的线程池。如果将 maximumPoolSize 设置为基本的无界值（如 Integer.MAX_VALUE），则允许池适应任意数量的并发任务。在大多数情况下，核心和最大池大小仅基于构造函数来设置，不过也可以使用 setCorePoolSize(int) 和 setMaximumPoolSize(int) 进行动态更改。

　　　　　　二、任务队列

　　　　　　　　workQueue是一个阻塞队列，用来存储执行的任务。所有的BlockingQueue都可用于workQueue。

　　　　　　　　　　如果有效的线程数小于 corePoolSize，则线程池首选添加新线程，而不进行排队。

　　　　　　　　　　如果有效的线程数大于等于 corePoolSize，则线程池首选将任务加入队列，而不添加新的线程。 

　　　　　　　　　　如果队列已满，则创建新的线程，当线程数超出 maximumPoolSize 时，任务将被拒绝。

　　　　　　　　常用的三种阻塞队列的实现：

　　　　　　　　　　1）直接提交。SynchronousQueue是一个不存储元素的阻塞队列。每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态。它将任务直接提交给线程而不存储任务。直接提交通常要求不限制 maximumPoolSizes 以避免拒绝新提交的任务。Executors.newCachedThreadPool使用了这个队列。

　　　　　　　　　　2）无界队列。LinkedBlockingQueue是一个基于链表结构的阻塞队列，默认的大小是Integer.MAX_VALUE。创建的线程就不会超过 corePoolSize，会使maximumPoolSize 的值无效。

　　　　　　　　　　3）有界队列。ArrayBlockingQueue是一个基于数组结构的有界阻塞队列。有助于防止资源耗尽，但是可能较难调整和控制。

　　　　　　三、饱和策略

　　　　　　　　当 Executor 已经关闭，或者 Executor 将有限边界用于最大线程和工作队列容量且已经饱和时，在方法 execute(Runnable) 中提交的新任务将被拒绝。线程池提供了4种饱和策略：

　　　　　　　　　　1）AbortPolicy。默认的饱和策略，直接抛出RejectedExecutionException异常。

　　　　　　　　　　2）CallerRunsPolicy。用调用者所在的线程来执行任务，此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。

　　　　　　　　　　3）DiscardPolicy。直接丢弃任务。

　　　　　　　　　　4）DiscardOldestPolicy。如果执行程序尚未关闭，则丢弃阻塞队列中最靠前的任务，然后重试执行新任务（如果再次失败，则重复此过程）。

　　　　　　　　也可以使用自定义的 RejectedExecutionHandler 类，但需要非常小心，尤其是当策略仅用于特定容量或排队策略时。

　　　　　　四、threadFactory

　　　　　　　　使用 ThreadFactory 创建新线程，默认情况下在同一个 ThreadGroup 中一律使用 Executors.defaultThreadFactory() 创建线程，这些线程具有相同的 NORM_PRIORITY 优先级和非守护进程状态。通过自定义的 ThreadFactory创建新线程，可以改变线程的名称、线程组、优先级、守护进程状态等。

　　　　　　五、workers用来存储工作线程，注意HashSet<Worker>是非线程安全的，访问时需要获取mainLock；

　　　　　　六、mainLock是一个独占式可重入锁，用来保证访问workers和其他监控变量（如largestPoolSize、completedTaskCount等）的线程安全。

　　　　　　七、keepAliveTime为线程池的工作线程空闲后，保持存活的时间。所以如果任务很多，并且每个任务执行的时间比较短，可以调大这个时间，提高线程的利用率。allowCoreThreadTimeout变量表示是否允许核心线程超时，如果allowCoreThreadTimeOut=false，那么当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize；如果allowCoreThreadTimeOut=true，那么当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=0。

　　　　执行任务（execute）

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();    //获取线程池的状态（runState和workerCount）
    //如果线程数小于corePoolSize，新建一个线程执行该任务。
    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);
        //如果线程数为0，执行addWorker方法。参数为null的原因是任务已经加入到队列，新建的线程从队列取任务执行即可。
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //线程池不是RUNNING状态或队列已满，尝试新建一个线程执行该任务。如果失败则拒绝该任务。
    else if (!addWorker(command, false))
        reject(command);
}

 　　　　新增线程（addWorker）

　　　　　　线程被封装在Worker类中。

//参数firstTask表示新建线程执行的第一个任务。如果firstTask为null，表示
//如果参数core=true，把corePoolSize作为线程数上限的判断条件；如果为false，把maximumPoolSize作为线程数上限的判断条件
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);
        /*
         * rs >= SHUTDOWN表示不再接受新任务。 
         * 1）线程池的运行状态为SHUTDOWN；2）firstTask == null；3）阻塞队列不为空，只有这三个条件同时满足才不返回false
         */
        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;
        
        //自旋CAS递增workerCount
        for (;;) {
            int wc = workerCountOf(c);
            //如果线程数超过上限，返回false。如果参数core=true，把corePoolSize作为线程数上限的判断条件；如果为false，把maximumPoolSize作为线程数上限的判断条件
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize))
                return false;
            //CAS递增线程数。如果成功，跳出最外层循环；如果失败，且运行状态没有改变，继续内层循环直到成功。
            if (compareAndIncrementWorkerCount(c))
                break retry;
            //判断runState是否改变，如果改变则继续外层循环
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }
    }
    
    //走到这说明需要新建线程，且workerCount更新成功
    //下面是新建Worker的过程。
    boolean workerStarted = false;    //新建的Worker是否启动标识
    boolean workerAdded = false;    //新建的Worker是否被添加到workers标识
    Worker w = null;
    try {
        final ReentrantLock mainLock = this.mainLock;
        w = new Worker(firstTask);    //新建Worker
        final Thread t = w.thread;
        //什么情况下线程会为null呢？在ThreadFactory创建线程失败时可能会出现。
        if (t != null) {
            mainLock.lock();    //获取mainLock锁。对workers（HashSet非线程安全）和largestPoolSize更新必须加锁
            try {
                // Recheck while holding lock.
                // Back out on ThreadFactory failure or if
                // shut down before lock acquired.
                int c = ctl.get();
                int rs = runStateOf(c);
                /*
                 *    如果运行状态是RUNNING，或者运行状态是SHUTDOWN且firstTask为null，才将新建的Worker添加到workers
                 */
                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable
                        throw new IllegalThreadStateException();
                    workers.add(w);
                    //更新largestPoolSize，标识线程池曾经出现过的最大线程数
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s;
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock();    //释放mainLock锁
            }
            if (workerAdded) {
                //启动线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        //新建的Worker未启动，进行失败处理
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

　　　　Worker类

　　　　　　每个线程被封装为一个Worker类实例。Worker类继承了AbstractQueuedSynchronizer，并实现了一个互斥非重入锁。Worker类同时继承了Runnable，Worker类的实例也是一个线程。

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    /**
     * This class will never be serialized, but we provide a
     * serialVersionUID to suppress a javac warning.
     */
    private static final long serialVersionUID = 6138294804551838833L;

    /** Thread this worker is running in.  Null if factory fails. */
    final Thread thread;    //处理任务的线程
    /** Initial task to run.  Possibly null. */
    Runnable firstTask;        //传入的任务
    /** Per-thread task counter */
    volatile long completedTasks;    //完成的任务数

    /**
     * Creates with given first task and thread from ThreadFactory.
     * @param firstTask the first task (null if none)
     */
    Worker(Runnable firstTask) {
        //同步状态初始化为-1，在执行runWorker方法前禁止中断当前线程
        setState(-1); // inhibit interrupts until runWorker 
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);    //通过ThreadFactory创建线程
    }

    /** Delegates main run loop to outer runWorker  */
    public void run() {
        runWorker(this);
    }

    // Lock methods
    //
    // The value 0 represents the unlocked state.
    // The value 1 represents the locked state.
    //实现了一个非重入互斥锁，state=0表示解锁状态，state=1表示加锁状态
    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;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

　　　　runWorker方法

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    //Worker初始化时同步状态置为-1，此处进行解锁操作目的是将同步状态置为0，允许中断。
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;    //是否因为异常跳出循环
    try {
        //如果firstTask为null则通过getTask()方法从队列中获取。
        //正常情况下，会一直执行While循环，如果队列为空，getTask()方法中会阻塞当前线程，getTask()返回null时会跳出循环
        while (task != null || (task = getTask()) != null) {
            w.lock();    //加Worker锁
            // 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
            /*
             * 如果线程池正在停止，要保证当前线程是中断状态
             * 如果不是，则要保证当前线程不是中断状态
             *  STOP状态要中断线程池中的所有线程，而这里使用Thread.interrupted()来判断是否中断是为了确保在RUNNING或者SHUTDOWN状态时线程是非中断状态的，因为Thread.interrupted()方法会复位中断的状态。
             */
            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();    //调用任务的run方法，而不是start()方法，因为Worker本身就是一个线程类
                } 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();        //释放Worker锁
            }
        }
        completedAbruptly = false;
    } finally {
        //跳出循环，执行processWorkerExit()方法
        processWorkerExit(w, completedAbruptly);
    }
}

　　　　getTask()方法

//如果返回null，在runWorker方法中会执行processWorkerExit，即关闭该线程。
private Runnable getTask() {
    //表示上次从队列获取任务是否超时
    boolean timedOut = false; // Did the last poll() time out?

    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // Check if queue empty only if necessary.
        // 如果rs >= STOP，或者 rs=SHUTDOWN且队列为空，此时不再接收新任务，将WorkerCount递减并返回null。
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();    //自旋CAS递减workerCount直到成功
            return null;
        }
        
        //timed用于判断是否需要重试控制
        boolean timed;      // Are workers subject to culling?

        for (;;) {
            //allowCoreThreadTimeOut默认是false，核心线程不进行超时控制，当线程数量大于corePoolSize时需要进行超时控制
            int wc = workerCountOf(c);
            timed = allowCoreThreadTimeOut || wc > corePoolSize;
            
            //如果wc <= maximumPoolSize ，且上次从队列获取任务超时或本次需要进行超时控制，则跳出内层循环。
            //timedOut=true表示上次从队列获取元素超时，说明队列在上次获取的keepAliveTime时间内是空的。
            //timed=true说明线程数量大于corePoolSize。
            //所以timedOut=true和timed=true同时满足则说明当前线程已经空闲了keepAliveTime时间，并且线程池的数量大于corePoolSize。这时就需要关闭多余的空闲线程（即compareAndDecrementWorkerCount并返回null）。
            if (wc <= maximumPoolSize && ! (timedOut && timed))
                break;
            //如果线程数量大于maximumPoolSize，或者上次从队列获取任务超时且本次需要进行超时控制。需要递减WorkerCount，如果递减成功则返回null
            if (compareAndDecrementWorkerCount(c))
                return null;
            //检查线程池运行状态是否改变。如果改变，那么继续外层循环，如果未改变，那么继续内层循环。
            c = ctl.get();  // Re-read ctl
            if (runStateOf(c) != rs)
                continue retry;
            // else CAS failed due to workerCount change; retry inner loop
        }

        try {
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :    
                //超时方式获取，注意keepAliveTime为超出corePoolSize大小的线程的空闲存活时间
                workQueue.take();    //阻塞方式获取，如果队列为空阻塞当前线程
            if (r != null)
                return r;
            timedOut = true;    //如果超时，继续循环。
        } catch (InterruptedException retry) {
            //如果发生中断，则将timedOut置为false，继续循环
            timedOut = false;
        }
    }
}

　　　　processWorkerExit方法

private void processWorkerExit(Worker w, boolean completedAbruptly) {
    //如果completedAbruptly=false，说明是由getTask返回null导致的，WorkerCount递减的操作已经执行。
    //如果completedAbruptly=true，说明是由执行任务的过程中发生异常导致，需要进行WorkerCount递减的操作。
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w);    //从workers中删除当前worker，对workers更新需要加mainLock锁。
    } finally {
        mainLock.unlock();
    }

    tryTerminate();
    
    //如果是异常结束（completedAbruptly=true），需要重新调用addWorker()增加一个线程，保持线程数量。
    //如果是由getTask()返回null导致的线程结束，需要进行以下判断：
    //    1）如果allowCoreThreadTimeOut=true且队列不为空，那么需要至少保证有一个线程。
    //    2）如果allowCoreThreadTimeOut=false,那么需要保证线程数大于等于corePoolSize。
    //
    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);
    }
}

　　　　tryTerminate()方法

//根据线程池状态判断是否结束线程池
final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        //如果线程池运行状态是RUNNING，或者大于等于TIDYING，或者运行状态为SHUTDOWN且队列为空，则直接return。
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        //如果线程数不为0，则中断一个空闲线程并return。为什么有这一步操作。
        if (workerCountOf(c) != 0) { // Eligible to terminate
            interruptIdleWorkers(ONLY_ONE);
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //尝试将状态设置为TIDYING状态，
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    //如果CAS成功,执行terminated()方法
                    terminated();
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll();
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

　　　　shutdown()方法

　　　　　　线程池运行状态由RUNNING到SHUTDOWN的转换。

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        //安全管理，检查方法调用者是否有权限中断Worker线程
        checkShutdownAccess();
        //运行状态改为SHUTDOWN
        advanceRunState(SHUTDOWN);    //自旋CAS
        //中断空闲线程
        interruptIdleWorkers();
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    //尝试结束线程池
    tryTerminate();
}

private void interruptIdleWorkers() {
    interruptIdleWorkers(false);
}

private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();    //对workers的操作需要获取mainLock
    try {
        //遍历所有的线程，如果没有被中断且获取锁成功则中断线程。获取锁失败时很可能该线程正在执行任务（woker执行任务时需要对woker加锁）。
        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();
    }
}

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

private void interruptWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)
            w.interruptIfStarted();
    } finally {
        mainLock.unlock();
    }
}

private List<Runnable> drainQueue() {
    BlockingQueue<Runnable> q = workQueue;
    List<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;
}

 　　

　　FutureTask源码分析

　　　　利用FutureTask可以实现获取异步任务的返回值、取消异步任务等功能。看一下ThreadPoolExecutor的submit方法。submit方法根据任务构造一个FutureTask对象并返回，在主线程中可以根据FutureTask提供的方法进行任务取消和获取异步任务的返回值。

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);    //实际执行的任务是ftask
    return ftask;
}

　　　　域

private volatile int state;        //状态，新创建时状态为NEW
private static final int NEW          = 0;    //新创建    
private static final int COMPLETING   = 1;    //正在执行
private static final int NORMAL       = 2;    //正常完成
private static final int EXCEPTIONAL  = 3;    //执行过程中出现异常
private static final int CANCELLED    = 4;    //被取消
private static final int INTERRUPTING = 5;    //
private static final int INTERRUPTED  = 6;

/** The underlying callable; nulled out after running */
private Callable<V> callable;    //要执行的任务
/** The result to return or exception to throw from get() */
private Object outcome; // non-volatile, protected by state reads/writes
/** The thread running the callable; CASed during run() */
private volatile Thread runner;    //执行callable的线程
/** Treiber stack of waiting threads */
private volatile WaitNode waiters;    //Treiber算法实现的栈，用于存储等待的线程

static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
}

　　　　　　状态的转换有以下几种情况：

　　　　　　　　1）NEW -> COMPLETING -> NORMAL 正常执行并返回；

　　　　　　　　2）NEW -> COMPLETING -> EXCEPTIONAL 执行过程中出现异常；

　　　　　　　　3）NEW -> CANCELLED 执行前被取消

　　　　　　　　4）NEW -> INTERRUPTING -> INTERRUPTED 取消时被中断。

　　　　初始化

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

public FutureTask(Runnable runnable, V result) {
    //由于Runnable没有返回值，通过Executors将Runnable转换为Callable。
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

　　　　执行任务-run()方法

public void run() {
    //只执行state=NEW的任务。如果state!=NEW说明任务已经执行。
    //如果state=NEW，则通过CAS将runner置为当前线程。如果失败说明其他线程已经执行。
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;    //任务执行结果
            boolean ran;    //任务执行期间是否发生异常
            try {
                result = c.call();    //执行任务
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                //如果发生异常，执行setException(ex)
                setException(ex);
            }
            //如果正常结束，执行set(result).
            if (ran)
                set(result);
        }
    } finally {
        // runner must be non-null until state is settled to
        // prevent concurrent calls to run()
        //不管任务执行是否正常，都需要将runner置为null
        runner = null;
        // state must be re-read after nulling runner to prevent
        // leaked interrupts
        //防止中断泄露，需要结合cancel方法研究
        //如果s>=INTERRUPTING，说明状态变换为NEW -> INTERRUPTING -> INTERRUPTED,即在取消时被中断。
        int s = state;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

　　　　　　任务执行正常结束：

//任务正常结束,通过CAS更新state为COMPLETING，如果成功，将state更新为NORMAL，唤醒等待线程。
protected void set(V v) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;    //将运行结果result赋给outcome
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        //删除和唤醒所有的等待线程
        finishCompletion();
    }
}

　　　　　　任务执行时发生异常：

//任务执行时发生异常，通过CAS更新state为COMPLETING，如果成功，将state更新为EXCEPTIONAL，唤醒等待线程
protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;    //将异常信息赋给outcome
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        finishCompletion();
    }
}

　　　　　　唤醒等待获取任务运行结果的线程：

private void finishCompletion() {
    // assert state > COMPLETING;
    //自旋CAS更新waiters为null直到成功
    for (WaitNode q; (q = waiters) != null;) {
        if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
            for (;;) {
                Thread t = q.thread;
                if (t != null) {
                    q.thread = null;
                    LockSupport.unpark(t);    //唤醒等待线程，WaitNode是在get方法中添加的
                }
                WaitNode next = q.next;
                if (next == null)
                    break;
                q.next = null; // unlink to help gc
                q = next;
            }
            break;
        }
    }

    done();    //hook方法，默认不执行任何操作，子类可以重写该方法完成指定的功能（例如：回调）

    callable = null;        // to reduce footprint
}

　　　　　　handlePossibleCancellationInterrupt方法要确保cancel(true)产生的中断发生在run或runAndReset方法执行的过程中。这里会循环的调用Thread.yield()来确保状态在cancel方法中被设置为INTERRUPTED。

private void handlePossibleCancellationInterrupt(int s) {
    // It is possible for our interrupter to stall before getting a
    // chance to interrupt us.  Let's spin-wait patiently.
    if (s == INTERRUPTING)
        while (state == INTERRUPTING)
            Thread.yield(); // wait out pending interrupt

    // assert state == INTERRUPTED;

    // We want to clear any interrupt we may have received from
    // cancel(true).  However, it is permissible to use interrupts
    // as an independent mechanism for a task to communicate with
    // its caller, and there is no way to clear only the
    // cancellation interrupt.
    //
    // Thread.interrupted();
}

　　　　获取运行结果-get()方法

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    //如果state为NEW或COMPLETING，调用awaitDone方法将当前线程添加到waiters中并阻塞
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    //如果已经完成（包括正常结束或异常结束），返回
    return report(s);
}

//如果超时则抛出TimeoutException异常
public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    return report(s);
}

　　　　　　awaitDone方法，阻塞线程。

//timed参数表示是否使用超时机制
private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;    //是否已经入栈
    for (;;) {
        //若当前线程被中断，则删除q并抛出InterruptedException()
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        //如果state大于COMPLETING，表明任务已经完成，则将节点q的线程置为null并返回状态值。
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //s==COMPLETING，说明任务已经执行完成但还没有设置最终状态。
        //Thread.yield();让当前正在运行的线程回到可运行状态，以允许其他线程（包括当前线程）获得运行的机会。注意目的是尝试让状态改变，继续下个循环。
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
        else if (q == null)
            q = new WaitNode();    //新建WaitNode节点
        //CAS添加到waiters栈，在阻塞之前先将节点q添加栈，入栈成功后queued更新为true。
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
                                                 q.next = waiters, q);
        else if (timed) {
            nanos = deadline - System.nanoTime();
            //如果已经过期，则删除节点q并返回
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);    //超时机制阻塞当前线程
        }
        else
            LockSupport.park(this);    //阻塞当前线程
    }
}
            
//删除指定节点（Treiber算法实现的栈）
private void removeWaiter(WaitNode node) {
    if (node != null) {
        node.thread = null;    //将线程置为null，因为下面要根据thread是否为null判断是否要把node移出
        retry:
        for (;;) {          // restart on removeWaiter race
            for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
                s = q.next;
                if (q.thread != null)
                    pred = q;
                else if (pred != null) {
                    pred.next = s;
                    if (pred.thread == null) // check for race
                        continue retry;
                }
                else if (!UNSAFE.compareAndSwapObject(this, waitersOffset, q, s))
                    continue retry;
            }
            break;
        }
    }
}

　　　　　　report方法，返回运行结果或抛出异常。

//任务完成返回执行结果或抛出异常
private V report(int s) throws ExecutionException {
    Object x = outcome;
    //如果任务正常完成，返回执行结果
    if (s == NORMAL)
        return (V)x;
    //如果s >= CANCELLED，说明任务被取消，那么就抛出CancellationException
    if (s >= CANCELLED)
        throw new CancellationException();
    //最后s==EXCEPTIONAL，任务执行时发生异常，抛出该异常
    throw new ExecutionException((Throwable)x);
}

　　　　取消任务-cancel方法

　　　　　　试图取消对此任务的执行。如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。当调用 cancel 时，如果调用成功，而此任务尚未启动，则此任务将永不运行。如果任务已经启动，则 mayInterruptIfRunning 参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。

public boolean cancel(boolean mayInterruptIfRunning) {
    //若state != NEW，说明任务已经启动，则直接返回失败。
    if (state != NEW)
        return false;
    //如果mayInterruptIfRunning为true，要中断当前执行任务的线程。
    if (mayInterruptIfRunning) {
        //CAS更新state为INTERRUPTING不成功，说明state已被改变（即state != NEW），则直接返回失败。如果成功则中断正在执行任务的线程，并唤醒等待获取结果的线程。
        if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
            return false;
        Thread t = runner;
        if (t != null)
            t.interrupt();    //中断当前线程
        //更新state为INTERRUPTED
        UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
    }
    //mayInterruptIfRunning=flase,CAS更新state为CANCELLED，若成功则唤醒等待的线程（不中断正在执行任务的线程），若失败返回false。
    else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
        return false;
    finishCompletion();
    return true;
}

　　Executors源码解析

　　　　Executors是一个工具类，提供了公共的静态方法，例如创建默认线程工厂、创建线程池、把Runnable包装成Callable的方法等。

　　　　创建默认线程工厂

　　　　　　DefaultThreadFactory类

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);    //线程池序号
    private final ThreadGroup group;    //线程组
    private final AtomicInteger threadNumber = new AtomicInteger(1);    //线程号
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" + poolNumber.getAndIncrement() + "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),    //线程名
                              0);
        //非守护线程
        if (t.isDaemon())
            t.setDaemon(false);
        //相同的优先级
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

　　　　　　创建默认工厂方法：

public static ThreadFactory defaultThreadFactory() {
    return new DefaultThreadFactory();
}

　　　　创建线程池

　　　　　　1）　newFixedThreadPool方法

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

　　　　　　　　固定线程数的线程池，corePoolSize和 maximumPoolSize 都被设置为nThreads，keepAliveTime=0，由于corePoolSize等于maximumPoolSize，所以keepAliveTime和maximumPoolSize参数是无效的。阻塞队列是LinkedBlockingQueue，是一个无界队列。正常情况下(未执行方法shutdown()或shutdownNow())，不会调用饱和策略。

　　　　　　2）newSingleThreadExecutor方法

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

　　　　　　　　单个线程的线程池，corePoolSize和maximumPoolSize都为1，其他同FixedThreadPool。能保证任务按顺序执行。

　　　　　　3）newCachedThreadPool方法

public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

　　　　　　　　线程数可改变的线程池，corePoolSize=0，maximumPoolSize=Integer.MAX_VALUE，核心线程数为0，最大线程数为CAPACITY（因为CAPACITY<Integer.MAX_VALUE）.keepAliveTime=60L，意味着CachedThreadPool中的空闲线程等待新任务的最长时间为60秒，空闲线程超过60秒后将会被终止。CachedThreadPool使用没有容量的SynchronousQueue作为线程池的工作队列.这意味着，如果主线程提交任务的速度高于maximumPool中线程处理任务的速度时，CachedThreadPool会不断创建新线程。极端情况下，CachedThreadPool会因为创建过多线程而耗尽CPU和内存资源。

　　　　把Runnable包装成Callable的方法

public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<T>(task, result);
}

public static Callable<Object> callable(Runnable task) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<Object>(task, null);
}

参考资料

　　深入理解Java线程池：ThreadPoolExecutor

　　聊聊并发（三）——JAVA线程池的分析和使用

　　FutureTask源码解析

　　FutureTask中的waiters为什么这么设计？

　　Treiber Stack