JUC源码分析26-线程池-ThreadPoolExecutor

功能说明

使用线程池通过线程的重用，降低线程创建的开销，降低资源消耗，额外还增加了一些线程执行的管理功能，方便对线程执行状态的监控。

类图

先看Executor–ExecutorService–AbstractExecutorService–ThreadPoolExecutor这条线的源码。

预热

Executor

/** 主要是解耦command的提交和执行 */
public interface Executor {

    /**
     * 提交一个command，执行由实现类自己定义，可以直接执行，也可以新开线程执行等等
     */
    void execute(Runnable command);
}

ExecutorService

接口ExecutorService继承Executor接口，提供线程终止的方法，扩展父接口execute()方法，提供future返回的submit方法。

public interface ExecutorService extends Executor {

    /**
     * 关闭之前的任务会继续执行，但是不会接受新的任务，如果已经关闭，调用不会有任务影响
     */
    void shutdown();

    /**
     * 尝试停止正在执行的任务，暂停等待处理的任务，返回等待执行的任务列表
     * 没办法保证一定能够停止执行中的任务
     */
    List<Runnable> shutdownNow();

    /**
     * 执行器是否已经关闭
     */
    boolean isShutdown();

    /**
     * 是否所有任务都已关闭，必须先调用shutdown或shutdownnow
     */
    boolean isTerminated();

    /**
     * 阻塞等待所有任务都执行完毕
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 下面3个方法都差不多，都是提交一个任务，返回一个Future，然后通过future.get()方法获取执行的结果
     */
    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

    /**
     * 执行给定的任务集合，当所有任务完成时，返回Future的结果
     */
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    /**
     * 执行指定的任务集合，如果其中一个成功完成，那就返回，其他没有完成的就取消
     */
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

submit()方法参数，runnable、callable、future3者简单的区别：
runnable没有返回的执行，callable有返回值的，future是可取消的callable。

AbstractExecutorService

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

2个newTask()方法分别将callable、runnable转换为future返回，看下FutureTask类图：

返回的FutureTask既可以当Runnable用，也可以当Future使用。
该抽象类实现ExecutorService的submit()方法会调用newTask()方法做转换：

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

public <T> Future<T> submit(Runnable task, T result) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task, result);
    execute(ftask);
    return ftask;
}

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

看下invokeAny()的实现：

public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
    throws InterruptedException, ExecutionException {
    try {
        return doInvokeAny(tasks, false, 0);
    } catch (TimeoutException cannotHappen) {
        assert false;
        return null;
    }
}

public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                       long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    return doInvokeAny(tasks, true, unit.toNanos(timeout));
}

/** invokeAny真正处理业务逻辑的地方，spring里面经常看到这样的方式，推荐使用 */
private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                        boolean timed, long nanos)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (tasks == null)
        throw new NullPointerException();
    int ntasks = tasks.size();
    if (ntasks == 0)
        throw new IllegalArgumentException();
    List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
    ExecutorCompletionService<T> ecs =
        new ExecutorCompletionService<T>(this); //将this的Executor再封装一层

    // For efficiency, especially in executors with limited
    // parallelism, check to see if previously submitted tasks are
    // done before submitting more of them. This interleaving
    // plus the exception mechanics account for messiness of main
    // loop.

    try {
        // Record exceptions so that if we fail to obtain any
        // result, we can throw the last exception we got.
        ExecutionException ee = null;
        long lastTime = timed ? System.nanoTime() : 0;
        Iterator<? extends Callable<T>> it = tasks.iterator();

        // Start one task for sure; the rest incrementally
        futures.add(ecs.submit(it.next())); //先提交一个执行
        --ntasks;
        int active = 1;

        for (;;) {
            Future<T> f = ecs.poll(); //从ecs中poll个出来，然后检查结果
            if (f == null) { //
                if (ntasks > 0) {
                    --ntasks;
                    futures.add(ecs.submit(it.next())); 
                    ++active;
                }
                else if (active == 0)
                    break;
                else if (timed) {
                    f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
                    if (f == null)
                        throw new TimeoutException();
                    long now = System.nanoTime();
                    nanos -= now - lastTime;
                    lastTime = now;
                }
                else
                    f = ecs.take();
            }
            if (f != null) { //不为null
                --active;
                try {
                    return f.get(); //返回结果
                } catch (ExecutionException eex) {
                    ee = eex;
                } catch (RuntimeException rex) {
                    ee = new ExecutionException(rex);
                }
            }
        }

        if (ee == null) 
            ee = new ExecutionException();
        throw ee; //异常存在就抛异常

    } finally {
        for (Future<T> f : futures)
            f.cancel(true); //有异常或者有结果返回前，取消所有提交的任务
    }
}

invokeAny()之前说过是执行一组任务，有一个完成就取消其他，这里都调用了doInvokeAny()来处理逻辑，大体流程是：
1. 先构造一个ExecutorCompletionService实例ecs(ecs简单解释，使用给定的执行器执行任务，按照给定的顺序返回执行结果future);
2. 先提交一个任务，然后for循环检查ecs的future，为null那就分情况，如果还有任务那就再提交一个，或有超时设置，实在不行那就阻塞等待；不为null那就future.get()获取结果返回，如果future.get有异常那就设置异常；
3. 退出for循环的时候检查是否有异常，最后再return或throw异常前取消掉提交的任务。

看下invokeAll()的源码：

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
    throws InterruptedException {
    if (tasks == null)
        throw new NullPointerException();
    List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
    boolean done = false;
    try {
        for (Callable<T> t : tasks) { //执行所有任务
            RunnableFuture<T> f = newTaskFor(t);
            futures.add(f);
            execute(f);
        }
        for (Future<T> f : futures) { //等待所有任务完成
            if (!f.isDone()) {
                try {
                    f.get();
                } catch (CancellationException ignore) {
                } catch (ExecutionException ignore) {
                }
            }
        }
        done = true;
        return futures;
    } finally {
        if (!done) //没执行完，那就取消任务
            for (Future<T> f : futures)
                f.cancel(true);
    }
}

public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                     long timeout, TimeUnit unit)
    throws InterruptedException {
    if (tasks == null || unit == null)
        throw new NullPointerException();
    long nanos = unit.toNanos(timeout);
    List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
    boolean done = false;
    try {
        for (Callable<T> t : tasks)
            futures.add(newTaskFor(t));

        long lastTime = System.nanoTime();

        // Interleave time checks and calls to execute in case
        // executor doesn't have any/much parallelism.
        Iterator<Future<T>> it = futures.iterator();
        while (it.hasNext()) {
            execute((Runnable)(it.next()));
            long now = System.nanoTime();
            nanos -= now - lastTime;
            lastTime = now;
            if (nanos <= 0) //超时返回future
                return futures;
        }
        //假如上面超时返回了，future还是有可能存在已经完成的任务
        for (Future<T> f : futures) {
            if (!f.isDone()) {
                if (nanos <= 0)
                    return futures;
                try {
                    f.get(nanos, TimeUnit.NANOSECONDS);
                } catch (CancellationException ignore) {
                } catch (ExecutionException ignore) {
                } catch (TimeoutException toe) {
                    return futures;
                }
                long now = System.nanoTime();
                nanos -= now - lastTime;
                lastTime = now;
            }
        }
        done = true;
        return futures;
    } finally {
        if (!done)
            for (Future<T> f : futures)
                f.cancel(true);
    }
}

大体的流程基本是1.提交任务；2.等待任务完成。有点不同的是超时的invokeAll()方法，即使超时返回了，future也有可能存在已经完成的任务，估计调用的时候还是要自己检查future是否null再加上future.get()是否null来判断。

ThreadPoolExecutor

线程池状态

/**ctl代表2个含义：高3位为线程池运行状态，低29位线程数量 */
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); //11100000000000000000000000000000
private static final int COUNT_BITS = Integer.SIZE - 3; //29
private static final int CAPACITY   = (1 << COUNT_BITS) - 1; //00011111111111111111111111111111

// runState is stored in the high-order bits
/**
 *   RUNNING:  接收新的任务并且也会处理已经提交等待的任务
 *   SHUTDOWN: 不会接收新的任务，但会处理已经提交等待的任务
 *   STOP:     不接受新任务，不处理已经提交等待的任务，而且还会中断处理中的任务
 *   TIDYING:  所有的任务被终止，workCount为0，为此状态时将会调用terminated()方法
 *   TERMINATED: terminated()调用完成
 *
 * 状态流转：
 * RUNNING -> SHUTDOWN
 *    On invocation of shutdown(), perhaps implicitly in finalize()
 * (RUNNING or SHUTDOWN) -> STOP
 *    On invocation of shutdownNow()
 * SHUTDOWN -> TIDYING
 *    When both queue and pool are empty
 * STOP -> TIDYING
 *    When pool is empty
 * TIDYING -> TERMINATED
 *    When the terminated() hook method has completed
 */
private static final int RUNNING    = -1 << COUNT_BITS; //11100000000000000000000000000000
private static final int SHUTDOWN   =  0 << COUNT_BITS; //00000000000000000000000000000000
private static final int STOP       =  1 << COUNT_BITS; //00100000000000000000000000000000
private static final int TIDYING    =  2 << COUNT_BITS; //01000000000000000000000000000000
private static final int TERMINATED =  3 << COUNT_BITS; //01100000000000000000000000000000

// Packing and unpacking ctl
private static int runStateOf(int c)     { return c & ~CAPACITY; } //&操作比较高3位获取线程池状态
private static int workerCountOf(int c)  { return c & CAPACITY; } // &比较低29位获取线程数量
private static int ctlOf(int rs, int wc) { return rs | wc; } //通过rs高3位运行状态|wc低29位线程数量计算最后的值

/*
 * Bit field accessors that don't require unpacking ctl.
 * These depend on the bit layout and on workerCount being never negative.
 */

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

/**
 * Attempt to CAS-increment the workerCount field of ctl.
 */
private boolean compareAndIncrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect + 1);
}

/**
 * Attempt to CAS-decrement the workerCount field of ctl.
 */
private boolean compareAndDecrementWorkerCount(int expect) {
    return ctl.compareAndSet(expect, expect - 1);
}

/**
 * Decrements the workerCount field of ctl. This is called only on
 * abrupt termination of a thread (see processWorkerExit). Other
 * decrements are performed within getTask.
 */
private void decrementWorkerCount() {
    do {} while (! compareAndDecrementWorkerCount(ctl.get()));
}

private void advanceRunState(int targetState) {
    for (;;) {
        int c = ctl.get();
        if (runStateAtLeast(c, targetState) ||
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

主要是ctl高低位分离，之前读写锁的时候也有这种处理。

ThreadPoolExecutor大致结构

/**
 * 一般来说，如果线程池大小没到corePoolSize大小，会新增线程运行，如果到了，那就入workQueue队列，等线程运行
 */
private final BlockingQueue<Runnable> workQueue;

/**
 * 一些操作需要加锁
 */
private final ReentrantLock mainLock = new ReentrantLock();

/**
 * 线程池，所有的线程
 */
private final HashSet<Worker> workers = new HashSet<Worker>();

/**
 * awaitTermination时条件
 */
private final Condition termination = mainLock.newCondition();

/**
 * 线程池线程最大数量
 */
private int largestPoolSize;

/**
 * 已经结束的任务，只有在关闭线程池的时候才累加
 */
private long completedTaskCount;

/**
 * 线程池工厂，里面有一个newThread()方法用来产生工作线程，如果构造没提供，默认有一个
 */
private volatile ThreadFactory threadFactory;

/**
 * 大部分用在线程池满了以后，新的任务过来，使用那种拒绝策略，默认会提供一个
 */
private volatile RejectedExecutionHandler handler;

/** 
 * 线程数量大于corePoolSize时，线程可以空闲的时间，如果设置了allowCoreThreadTimeOut，小于corePoolSize时也一样处理，否则就等待任务到来
 */
private volatile long keepAliveTime;

/**
 * false，核心线程空闲等待，true的话就是用keepAliveTime超时控制获取任务
 */
private volatile boolean allowCoreThreadTimeOut;

/**
 * 核心线程数量
 */
private volatile int corePoolSize;

/**
 * 跟largestPoolSize这个不一样，这个用来控制线程池大小
 */
private volatile int maximumPoolSize;

/**
 * 默认的拒绝策略
 */
private static final RejectedExecutionHandler defaultHandler =
    new AbortPolicy();

构造函数：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         threadFactory, defaultHandler);
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), handler);
}

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

构造函数基本就是对那些变量的检查赋值。
在看execute()方法前先看下默认提供的线程工厂和拒绝策略。

/** ThreadPoolExecutor构造的时候如果不传入，默认这个，用于产生工作线程 */
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-";
    }
    /** 返回一个线程：name为pool-线程池序列-thread-线程序列，优先级为5，非守护线程 */
    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;
    }
}

线程池构造如果不传参，默认提供了一个拒绝策略AbortPolicy

public static class CallerRunsPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code CallerRunsPolicy}.
     */
    public CallerRunsPolicy() { }

    /**
     * 如果线程池没有关闭，在调用者线程直接运行该任务，否则discard
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

public static class AbortPolicy implements RejectedExecutionHandler {
    /**
     * Creates an {@code AbortPolicy}.
     */
    public AbortPolicy() { }

    /**
     * throws RejectedExecutionException.直接抛出异常
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        throw new RejectedExecutionException("Task " + r.toString() +
                                             " rejected from " +
                                             e.toString());
    }
}

public static class DiscardPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code DiscardPolicy}.
     */
    public DiscardPolicy() { }

    /**
     * 什么都不做
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
    }
}

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
    /**
     * Creates a {@code DiscardOldestPolicy} for the given executor.
     */
    public DiscardOldestPolicy() { }

    /**
     * 线程池没有关闭就把任务队列的第一个丢弃然后执行新的
     */
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        if (!e.isShutdown()) {
            e.getQueue().poll();
            e.execute(r);
        }
    }
}

实在不满意提供的，那就自己写个吧。

核心代码流程

按照代码调用流程来分解。

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(); //double-check
        if (! isRunning(recheck) && remove(command)) //线程池关闭，remove任务，按照给定的策略reject
            reject(command);
        else if (workerCountOf(recheck) == 0) //如果线程池还在或者remove失败，但是核心线程已经没有了，那就开一个执行队列中的任务
            addWorker(null, false);
    }
    else if (!addWorker(command, false)) //如果检查的时候线程池就关闭了或者线队列满了入队列失败，那就再开一个线程，如果失败那就reject
        reject(command);
}

addWorker

/**
 * 基于当前线程池的状态和大小(core:true使用corePoolSize，false使用maximumPoolSize)，能否加入一个新的工作类
 */
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        /** 1.如果为Running状态无所谓，不管新增线程还是接收新任务都可以
         * 2.如果为shutdown状态那就只能处理任务，不能接收任务。这时入参firstTask必须null且，队列不为空，可以增加一个线程来处理队列，但不能新增任务
         * 3.其他状态直接false
         */
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;

        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                wc >= (core ? corePoolSize : maximumPoolSize)) //根据core检验大小
                return false;
            if (compareAndIncrementWorkerCount(c)) //线程数量加1
                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 {
        final ReentrantLock mainLock = this.mainLock;
        w = new Worker(firstTask);
        final Thread t = w.thread; //这里产生Thread时候可能为null，workerStarted为false，finally会处理addWorkerFailed
        if (t != null) {
            mainLock.lock(); //线程池主锁
            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);

                if (rs < SHUTDOWN ||
                    (rs == SHUTDOWN && firstTask == null)) {
                    if (t.isAlive()) // precheck that t is startable 刚开始对这里的处理感觉又疑问，后来想到可以自定义线程工厂newThread，存在提前启动线程可能
                        throw new IllegalThreadStateException();
                    workers.add(w); //加入线程池
                    int s = workers.size();
                    if (s > largestPoolSize)
                        largestPoolSize = s; //设置线程池大小
                    workerAdded = true;
                }
            } finally {
                mainLock.unlock(); //解锁
            }
            if (workerAdded) { //true说明已经加入线程池，那就start吧
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted) //线程t为null或有异常产生，workerStarted为false
            addWorkerFailed(w);
    }
    return workerStarted;
}

Worker

addWorker中用到了Worker：

w = new Worker(firstTask);
final Thread t = w.thread;
...
t.start();

看下Worker类：

/**
 * Class Worker mainly maintains interrupt control state for
 * threads running tasks, along with other minor bookkeeping.
 * This class opportunistically extends AbstractQueuedSynchronizer
 * to simplify acquiring and releasing a lock surrounding each
 * task execution.  This protects against interrupts that are
 * intended to wake up a worker thread waiting for a task from
 * instead interrupting a task being run.  We implement a simple
 * non-reentrant mutual exclusion lock rather than use
 * ReentrantLock because we do not want worker tasks to be able to
 * reacquire the lock when they invoke pool control methods like
 * setCorePoolSize.  Additionally, to suppress interrupts until
 * the thread actually starts running tasks, we initialize lock
 * state to a negative value, and clear it upon start (in
 * runWorker).
 * 英文保留，便于后面的时候对照，以免歧义：
 * Worker实现Runnable接口，所以本身可以作为参数传给Thread运行，继承AQS，实现的是独占模式的api
 * 主要是为了控制线程task运行的中断状态，每次运行前后加解锁
 * 没有使用可重入锁，主要是为了避免获得锁的情况下去修改线程池的一些加锁的方法
 * AQS的初始状态为-1，后面lock为1，unlock为0，可以简单判断state大于等于0值来判断是否运行过
 */
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) {
        setState(-1); // 初始为-1
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this); //线程工厂newThread
    }

    /** Delegates main run loop to outer runWorker  */
    public void run() {
        runWorker(this); //线程运行后最后会调用ThreadPoolExecutor的runWorker，后面看
    }

    // AQS的独占api实现
    //
    // 0表示unlocked
    // 1表示lock

    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()) { //检查aqs状态和线程状态，只有运行过采取中断
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}

runWorker

调用t.start()后，最后调用到runWorker()，这是线程处理任务最重要的方法。runWorker()大概处理流程是：初始firstTask不为null就先处理这个任务，然后循环再从workQueue获取getTask来处理，如果队列也取不到任务了，那就退出了，这时候就要看keepAliveTime和allowCoreThreadTimeOut了决定是，大概先这样理解，细节再说。

/**
 * Main worker run loop.  Repeatedly gets tasks from queue and
 * executes them, while coping with a number of issues:
 *
 * 1. We may start out with an initial task, in which case we
 * don't need to get the first one. Otherwise, as long as pool is
 * running, we get tasks from getTask. If it returns null then the
 * worker exits due to changed pool state or configuration
 * parameters.  Other exits result from exception throws in
 * external code, in which case completedAbruptly holds, which
 * usually leads processWorkerExit to replace this thread.
 *
 * 2. Before running any task, the lock is acquired to prevent
 * other pool interrupts while the task is executing, and
 * clearInterruptsForTaskRun called to ensure that unless pool is
 * stopping, this thread does not have its interrupt set.
 *
 * 3. Each task run is preceded by a call to beforeExecute, which
 * might throw an exception, in which case we cause thread to die
 * (breaking loop with completedAbruptly true) without processing
 * the task.
 *
 * 4. Assuming beforeExecute completes normally, we run the task,
 * gathering any of its thrown exceptions to send to
 * afterExecute. We separately handle RuntimeException, Error
 * (both of which the specs guarantee that we trap) and arbitrary
 * Throwables.  Because we cannot rethrow Throwables within
 * Runnable.run, we wrap them within Errors on the way out (to the
 * thread's UncaughtExceptionHandler).  Any thrown exception also
 * conservatively causes thread to die.
 *
 * 5. After task.run completes, we call afterExecute, which may
 * also throw an exception, which will also cause thread to
 * die. According to JLS Sec 14.20, this exception is the one that
 * will be in effect even if task.run throws.
 *
 * The net effect of the exception mechanics is that afterExecute
 * and the thread's UncaughtExceptionHandler have as accurate
 * information as we can provide about any problems encountered by
 * user code.
 *
 * @param w the worker
 */
final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask; //线程初始的task
    w.firstTask = null;
    w.unlock(); // allow interrupts 这里是worker构造默认的aqs为-1，这里unlock下，容许中断
    boolean completedAbruptly = true; //线程退出的原因，true是任务导致，false是线程正常退出
    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; //线程正常退出，false
    } finally {
        processWorkerExit(w, completedAbruptly); //work退出，做收尾工作
    }
}

getTask

/**
 * 存在阻塞或超时获取任务或由于下列原因返回null:
 * 1. 超过设置的线程池大小maximumPoolSize；
 * 2. 线程池stop.
 * 3. 线程池shutdown，队列为空.
 * 4. 线程超时等待任务，This worker timed out waiting for a task, and timed-out
 *    workers are subject to termination (that is,
 *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
 *    both before and after the timed wait.
 *
 * @return task, or null if the worker must exit, in which case
 *         workerCount is decremented
 */
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out? 控制超时获取poll后是否退出，return null

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

        // Check if queue empty only if necessary.
        // shutdown时如果队列空，那就直接worker减1，返回null
        // Stop往后的状态，那就null，这时候也不会去处理任务
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount();
            return null;
        }
        //到这里的时候线程池状态为running或者shutdown但队列不空
        boolean timed;      // 是否超时获取task

        for (;;) {
            int wc = workerCountOf(c);
            /** 
            * 1.容许核心线程超时即allowCoreThreadTimeOut为true
            * 2.不容许容许核心线程超时即allowCoreThreadTimeOut为false，检查线程池数量：
            * 如果大于核心线程数量，那就超时poll获取，否则核心线程阻塞获取
            */
            timed = allowCoreThreadTimeOut || wc > corePoolSize;

            //timeout第一次为false，所以肯定会有一次poll或take发生，这里控制的应该是在发生一次后是否还继续超时获取
            if (wc <= maximumPoolSize && ! (timedOut && timed))
                break;
            if (compareAndDecrementWorkerCount(c)) //不需要，那就扣减返回null
                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) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true; 
        } catch (InterruptedException retry) {
            timedOut = false; //响应中断，重新开始
        }
    }
}

processWorkerExit

在上面runWorker()中如果getTask()返回null或者在用户task.run过程中有异常出现时需要对线程退出做收尾工作processWorkerExit():

/**
 * 线程退出收尾
 */
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) // 为true的时候，用户线程运行异常，需要扣减，false的时候为getTask方法中扣减线程数量
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks;
        workers.remove(w); //从线程池移除
    } finally {
        mainLock.unlock();
    }

    tryTerminate(); //有worker线程移除，可能是最后一个线程退出需要尝试终止线程池

    int c = ctl.get();
    if (runStateLessThan(c, STOP)) { //线程池可能为running或shutdown状态
        if (!completedAbruptly) { //这里是线程正常退出
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize; //检查allowCoreThreadTimeOut字段，看是否需要维持核心线程数量
            if (min == 0 && ! workQueue.isEmpty()) //如果不需要维持核心线程数量但是队列不空，那至少保持一个线程处理队列
                min = 1;
            if (workerCountOf(c) >= min) //如果线程数量大于最少数量，直接返回，否则下面至少要addWorker一个
                return; // replacement not needed
        }
        addWorker(null, false); //用户异常退出，或者线程数量小于需要维护的数量，那就add
    }
}

addWorkerFailed

最开始的时候addWorker()时产生thread失败或线程已经提前启动时的处理.

/**
 * 回滚worker创建
 */
private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w); // 1.有可能已经加入线程池，remove
        decrementWorkerCount(); //2.线程池数量减1
        tryTerminate(); //3.涉及线程的扣钱都有要去尝试终止线程池
    } finally {
        mainLock.unlock();
    }
}

tryTerminate

在addworker失败和work处理任务失败退出都涉及到线程的扣钱，可能就剩下这一个线程，就需要关闭线程池，所以需要尝试下关闭线程池。

/**
 * 尝试终止线程池
 */
final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        //线程池状态为Running\状态已经是TIDYING或TERMINATED说明已经终止了\SHUTDOWN但是队列不空还需要处理任务，不需要终止
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateOf(c) == SHUTDOWN && ! workQueue.isEmpty()))
            return;
        // 到这里只剩下，shutdown状态队列空，Stop状态
        if (workerCountOf(c) != 0) { 
            //线程池还有线程，但是队列没有任务了，需要中断唤醒等待任务的线程（runwoker的时候首先就通过w.unlock设置线程可中断，getTask最后面的catch处理中断）
            //中断空闲线程传入的true，唤醒一个等待线程来处理就行
            interruptIdleWorkers(ONLY_ONE); 
            return;
        }

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) { //线程池状态转为TIDYING
                try {
                    terminated();
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0)); //线程池状态转为TERMINATED
                    termination.signalAll(); //awaitTermination的termination.awaitNanos(nanos)需要signal
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        // else retry on failed CAS
    }
}

/** 空实现，子类覆盖，最好先调用super.terminated() */
protected void terminated() { }

interruptWorkers-interruptIdleWorkers

/**
 * 调用worker的interruptIfStarted，中断已经start的所有线程
 */
private void interruptWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)
            w.interruptIfStarted();
    } finally {
        mainLock.unlock();
    }
}

/**
 * 根据参数中断一个还是所有空闲线程，注意是空闲线程，interruptWorkers这个方法，不管空闲不空闲都会中断
 */
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()) { //trylock保证是空闲的线程
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}

/**
 * 还是调用上面那个有参数的方法，防止忘记true\false含义
 */
private void interruptIdleWorkers() {
    interruptIdleWorkers(false);
}

/** 中断空闲线程时只处理一个 */
private static final boolean ONLY_ONE = true;

注意：interruptWorkers中断所有线程，interruptIdleWorkers是中断空闲的线程。

ExecutorService接口实现

shutdown

/** 1.推进状态到shutdown，不接受新任务(addworker时检查状态会控制) 2.中断所有空闲线程，会检查线程池状态和队列是否空，保证已经提交的肯定会执行*/
public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN); //推进线程池状态
        interruptIdleWorkers(); //中断空闲的线程
        onShutdown(); // hook for ScheduledThreadPoolExecutor
    } finally {
        mainLock.unlock();
    }
    tryTerminate(); //最后线程池尝试关闭下
}

/**
 * 推进状态到targetState
 *
 * @param targetState the desired state, either SHUTDOWN or STOP
 *        (but not TIDYING or TERMINATED -- use tryTerminate for that)
 */
private void advanceRunState(int targetState) {
    for (;;) {
        int c = ctl.get();
        if (runStateAtLeast(c, targetState) ||
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}

/** 空实现，子类覆盖*/
void onShutdown() {
}

shutdownNow

/** 中断所有线程，不管是执行中还是getTask等待的，返回没执行的task列表 */
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 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;
}

awaitTermination

/** 之前的shutdown和shutdownnow是不等待线程池变为中断状态的，这里等待指定超时时间 */
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); //tryTerminate()会termination.signalAll()
        }
    } finally {
        mainLock.unlock();
    }
}

isTerminated

public boolean isShutdown() {
    return ! isRunning(ctl.get());
}

/**
 * 在running和TERMINATED之间的3个状态
 */
public boolean isTerminating() {
    int c = ctl.get();
    return ! isRunning(c) && runStateLessThan(c, TERMINATED);
}

/** TERMINATED状态 */
public boolean isTerminated() {
    return runStateAtLeast(ctl.get(), TERMINATED);
}

其他辅助方法

上面看完基本线程这个类就Ok了，这里看下一些辅助方法。

finalize

/**
 * Invokes {@code shutdown} when this executor is no longer
 * referenced and it has no threads.
 */
protected void finalize() {
    shutdown(); //默认调用shutdown处理已提交的任务
}

提前启动线程

/**
 * 启动一个线程
 */
public boolean prestartCoreThread() {
    return workerCountOf(ctl.get()) < corePoolSize &&
        addWorker(null, true);
}

/**
 * 确保肯定启动一个线程
 */
void ensurePrestart() {
    int wc = workerCountOf(ctl.get());
    if (wc < corePoolSize)
        addWorker(null, true);
    else if (wc == 0)
        addWorker(null, false);
}

/**
 * 启动所有核心线程
 */
public int prestartAllCoreThreads() {
    int n = 0;
    while (addWorker(null, true))
        ++n;
    return n;
}

其他的方法大都是get\set方法，不关心，线程池这个类还需要多看看，有些细节需要深入下，这个看懂了，才能去看其他的。