Java Executor 框架

     Executor框架是指java5中引入的一系列并发库中与executor相关的功能类，包括Executor、Executors、ExecutorService、CompletionService、Future、Callable等。（图片引用自http://www.javaclubcn.com/a/jichuzhishi/2012/1116/170.html）

     本篇博文分析Executor中几个比较重要的接口和类。

     Executor

public interface Executor {
     void execute(Runnable command);
}

     Executor接口是Executor框架中最基础的部分，定义了一个用于执行Runnable的execute方法。它没有直接的实现类，有一个重要的子接口ExecutorService。

     ExecutorService

//继承自Executor接口
public interface ExecutorService extends Executor {
    /**
     * 关闭方法，调用后执行之前提交的任务，不再接受新的任务
     */
    void shutdown();
    /**
     * 从语义上可以看出是立即停止的意思，将暂停所有等待处理的任务并返回这些任务的列表
     */
    List<Runnable> shutdownNow();
    /**
     * 判断执行器是否已经关闭
     */
    boolean isShutdown();
    /**
     * 关闭后所有任务是否都已完成
     */
    boolean isTerminated();
    /**
     * 中断
     */
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    /**
     * 提交一个Callable任务
     */
    <T> Future<T> submit(Callable<T> task);
    /**
     * 提交一个Runable任务，result要返回的结果
     */
    <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;
    /**
     * 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。
     */
    <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;
}

    ExecutorService接口继承自Executor接口，定义了终止、提交任务、跟踪任务返回结果等方法。

    ExecutorService涉及到Runnable、Callable、Future接口，这些接口的具体内容如下。

// 实现Runnable接口的类将被Thread执行，表示一个基本的任务
public interface Runnable {
    // run方法就是它所有的内容，就是实际执行的任务
    public abstract void run();
}
// Callable同样是任务，与Runnable接口的区别在于它接收泛型，同时它执行任务后带有返回内容
public interface Callable<V> {
    // 相对于run方法的带有返回值的call方法
    V call() throws Exception;
}

// Future代表异步任务的执行结果
public interface Future<V> {

    /**
     * 尝试取消一个任务，如果这个任务不能被取消（通常是因为已经执行完了），返回false，否则返回true。
     */
    boolean cancel(boolean mayInterruptIfRunning);

    /**
     * 返回代表的任务是否在完成之前被取消了
     */
    boolean isCancelled();

    /**
     * 如果任务已经完成，返回true
     */
    boolean isDone();

    /**
     * 获取异步任务的执行结果（如果任务没执行完将等待）
     */
    V get() throws InterruptedException, ExecutionException;

    /**
     * 获取异步任务的执行结果（有最常等待时间的限制）
     *
     *  timeout表示等待的时间，unit是它时间单位
     */
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

     ExecutorService有一个子接口ScheduledExecutorService和一个抽象实现类AbstractExecutorService。

     ScheduledExecutorService

// 可以安排指定时间或周期性的执行任务的ExecutorService
public interface ScheduledExecutorService extends ExecutorService {
    /**
     * 在指定延迟后执行一个任务，只执行一次
     */
    public ScheduledFuture<?> schedule(Runnable command,
                       long delay, TimeUnit unit);
    /**
     * 与上面的方法相同，只是接受的是Callable任务
     */
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                       long delay, TimeUnit unit);
    /**
     * 创建并执行一个周期性的任务，在initialDelay延迟后每间隔period个单位执行一次，时间单位都是unit
     * 每次执行任务的时间点是initialDelay, initialDelay+period, initialDelay + 2 * period...
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                          long initialDelay,
                          long period,
                          TimeUnit unit);
    /**
     * 创建并执行一个周期性的任务，在initialDelay延迟后开始执行，在执行结束后再延迟delay个单位开始执行下一次任务，时间单位都是unit
     * 每次执行任务的时间点是initialDelay, initialDelay+(任务运行时间+delay), initialDelay + 2 * (任务运行时间+delay)...
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                             long initialDelay,
                             long delay,
                             TimeUnit unit);
}

    ScheduledExecutorService定义了四个方法，已经在上面给出基本的解释。ScheduledExecutorService有两个实现类，分别是DelegatedScheduledExecutorService和ScheduledThreadPoolExecutor，将在后面介绍。还需要解释的是ScheduledFuture。

    ScheduledFuture继承自Future和Delayed接口，自身没有添加方法。Delayed接口定义了一个获取剩余延迟的方法。

     AbstractExecutorService

// 提供ExecutorService的默认实现
public abstract class AbstractExecutorService implements ExecutorService {
    /*
     * 为指定的Runnable和value构造一个FutureTask，value表示默认被返回的Future
     */
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
    /*
     * 为指定的Callable创建一个FutureTask
     */
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
        return new FutureTask<T>(callable);
    }
    /*
     * 提交Runnable任务
     */
    public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        // 通过newTaskFor方法构造RunnableFuture，默认的返回值是null
        RunnableFuture<Object> ftask = newTaskFor(task, null);
        // 调用具体实现的execute方法
        execute(ftask);
        return ftask;
    }
    /*
     * 提交Runnable任务
     */
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        // 通过newTaskFor方法构造RunnableFuture，默认的返回值是result
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }
    /*
     * 提交Callable任务
     */
    public <T> Future<T> submit(Callable<T> task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task);
        execute(ftask);
        return ftask;
    }

    /*
     * doInvokeAny的具体实现（核心内容），其它几个方法都是重载方法，都对这个方法进行调用
     * tasks 是被执行的任务集，timed标志是否定时的，nanos表示定时的情况下执行任务的限制时间
     */
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
        // tasks空判断
        if (tasks == null)
            throw new NullPointerException();
        // 任务数量
        int ntasks = tasks.size();
        if (ntasks == 0)
            throw new IllegalArgumentException();
        // 创建对应数量的Future返回集
        List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
        ExecutorCompletionService<T> ecs =
            new ExecutorCompletionService<T>(this);
        try {
            // 执行异常
            ExecutionException ee = null;
            // System.nanoTime()根据系统计时器当回当前的纳秒值
            long lastTime = (timed)? System.nanoTime() : 0;
            // 获取任务集的遍历器
            Iterator<? extends Callable<T>> it = tasks.iterator();

            // 向执行器ExecutorCompletionService提交一个任务，并将结果加入futures中
            futures.add(ecs.submit(it.next
            // 修改任务计数器
            --ntasks;
            // 活跃任务计数器
            int active = 1;
            for (;;) {
                // 获取并移除代表已完成任务的Future，如果不存在，返回null
                Future<T> f = ecs.poll();
                if (f == null) {
                    // 没有任务完成，且任务集中还有未提交的任务
                    if (ntasks > 0) {
                        // 剩余任务计数器减1
                        --ntasks;
                        // 提交任务并添加结果
                        futures.add(ecs.submit(it.next()));
                        // 活跃任务计数器加1
                        ++active;
                    }
                    // 没有剩余任务，且没有活跃任务（所有任务可能都会取消），跳过这一次循环
                    else if (active == 0)
                        break;
                    else if (timed) {
                        // 获取并移除代表已完成任务的Future，如果不存在，会等待nanos指定的纳秒数
                        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();
                }
                // f不为空说明有一个任务完成了
                if (f != null) {
                    // 已完成一个任务，所以活跃任务计数减1
                    --active;
                    try {
                        // 返回该任务的结果
                        return f.get();
                    } catch (InterruptedException ie) {
                        throw ie;
                    } 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);
        }
    }

    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
        try {
            // 非定时任务的doInvokeAny调用
            return doInvokeAny(tasks, false, 0);
        } catch (TimeoutException cannotHappen) {
            assert false;
            return null;
        }
    }
    // 定时任务的invokeAny调用，timeout表示超时时间，unit表示时间单位
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
        return doInvokeAny(tasks, true, unit.toNanos(timeout));
    }
    // 无超时设置的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) {
                // 如果某个任务没完成，通过f调用get()方法
                if (!f.isDone()) {
                    try {
                        // get方法等待计算完成，然后获取结果(会等待)。所以调用get后任务就会完成计算，否则会等待
                        f.get();
                    } catch (CancellationException ignore) {
                    } catch (ExecutionException ignore) {
                    }
                }
            }
            // 标志所有任务执行完成
            done = true;
            // 返回结果
            return futures;
        } finally {
            // 假如没有完成所有任务（可能是发生异常等情况），将任务取消
            if (!done)
                for (Future<T> f : futures)
                    f.cancel(true);
        }
    }
    // 超时设置的invokeAll方法
    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 {
            // 遍历tasks，将任务转为RunnableFuture
            for (Callable<T> t : tasks)
                futures.add(newTaskFor(t));
            // 记录当前时间（单位是纳秒）
            long lastTime = System.nanoTime();
            // 获取迭代器
            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)
                    return futures;
            }

            for (Future<T> f : futures) {
                // 如果有任务没完成
                if (!f.isDone()) {
                    // 时间已经用完，返回保存任务状态的结果集
                    if (nanos <= 0)
                        return futures;
                    try {
                        // 获取计算结果，最多等待给定的时间nanos，单位是纳秒
                        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);
        }
    }
}

    AbstractExecutor实现了ExecutorService接口的部分方法。具体代码的分析在上面已经给出。

    AbstractExecutor有两个子类：DelegatedExecutorService、ThreadPoolExecutor。将在后面介绍。

    下面是AbstractExecutor中涉及到的RunnableFuture、FutureTask、ExecutorCompletionService。

    RunnableFuture继承自Future和Runnable，只有一个run()方法（Runnable中已经有一个run方法了，为什么RunnableFuture还要重新写一个run方法呢？求高手指教）。RunnableFuture接口看上去就像是Future和Runnable两个接口的组合。

    FutureTask实现了RunnableFuture接口，除了实现了Future和Runnable中的方法外，它还有自己的方法和一个内部类Sync。

    ExecutorCompletionService实现了CompletionService接口，将结果从复杂的一部分物种解耦出来。这些内容后续会介绍，不过这里先介绍框架中的其它内容，弄清整体框架。

    下面看继承自AbstractExecutorService的ThreadPoolExecutor。

    ThreadPoolExecutor

public class ThreadPoolExecutor extends AbstractExecutorService {
    // 检查关闭的权限        
    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");
    /* runState提供了主要的生命周期控制，可取值有以下几个：
     * RUNNING:接受新的任务，处理队列中的任务
     * SHUTDOWN:不再接受新的任务，但是处理队列中的任务
     * STOP:不接受新任务，也不处理队列中的任务，打断正在处理的任务
     * TERMINATED:和STOP类似，同时终止所有线程
     * RUNNING -> SHUTDOWN
     *    On invocation of shutdown(), perhaps implicitly in finalize()
     * (RUNNING or SHUTDOWN) -> STOP
     *    On invocation of shutdownNow()
     * SHUTDOWN -> TERMINATED
     *    When both queue and pool are empty
     * STOP -> TERMINATED
     *    When pool is empty
     * 
     */
    volatile int runState;
    static final int RUNNING    = 0;
    static final int SHUTDOWN   = 1;
    static final int STOP       = 2;
    static final int TERMINATED = 3;

    // 用于保持任务的队列
    private final BlockingQueue<Runnable> workQueue;
    // poolSize, corePoolSize, maximumPoolSize, runState, workers set的更新锁
    private final ReentrantLock mainLock = new ReentrantLock();
    // mainLock锁的一个Condition实例
    private final Condition termination = mainLock.newCondition();
    // 保持线程池中所有的工作线程。只有获取mainLock锁后才能访问。
    private final HashSet<Worker> workers = new HashSet<Worker>();
    // 空闲线程的等待时间，大为是纳秒
    private volatile long  keepAliveTime;
    // 是否允许核心线程“活着” false（默认值）允许，哪怕空闲；true则使用keepAliveTime来控制等待超时时间
    private volatile boolean allowCoreThreadTimeOut;
    // 核心线程池的大小
    private volatile int   corePoolSize;
    // pool size最大值
    private volatile int   maximumPoolSize;
    // 当前pool大小
    private volatile int   poolSize;
    // 拒绝执行的处理器 顾名思义，当一个任务被拒绝执行后将同个这个处理器进行处理
    private volatile RejectedExecutionHandler handler;
    // 线程工厂，用于创建线程
    private volatile ThreadFactory threadFactory;
    // 最终pool size达到的最大值
    private int largestPoolSize;
    // 已完成任务计数
    private long completedTaskCount;
    // 默认的拒绝执行的处理器
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
    /**
     * 关于借个size的说明：
     * 线程池数量poolSize指工作线程Worker对象的集合workers的实际大小，通过workers.size()可直接获得。            
     * 核心线程池数量corePoolSize，可理解为工作线程Worker对象的集合workers的目标大小。
     * 如果poolSize > corePoolSize，那么ThreadPoolExecutor就会有机制在适当的时候回收闲置的线程。
     * 最大线程池数量maxPoolSize，就是工作线程Worker对象的集合workers的大小上限。
     * 假如说任务队列满了，再来新任务时，若poolSize还没达到maxPoolSize，则继续创建新的线程来执行新任务，
     * 若不幸poolSize达到了上限maxPoolSize，那不能再创建新的线程了，只能采取reject策略来拒绝新任务。
     */
    /** 构造方法 开始*/
    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) {
        // 非法输入（明显这些值都是不能小于0的）
        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;
    }
    /** 构造方法 结束*/
    

    // 执行Runnable任务
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
            /*如果当前线程数量poolSize>=核心线程数量corePoolSize，
            那当然无法再把当前任务加入到核心线程池中执行了，于是进花括号选择其他的策略执行；
            如果poolSize没有达到corePoolSize，那很自然是把当前任务放到核心线程池执行，
            也就是执行逻辑或运算符后的方法addIfUnderCorePoolSize(command)。
            “放到核心线程池执行”是什么意思呢？
            就是new 一个新工作线程放到workers集合中，让这个新线程来执行当前的任务command，而这个新线程可以认为是核心线程池中的其中一个线程。*/
        if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
            // 线程池状态时RUNNING且能将任务添加到worker队列中
            if (runState == RUNNING && workQueue.offer(command)) {
                // 加入了队列以后，只要保证有工作线程就ok了，工作线程会自动去执行任务队列的。
                // 所以判断一下if ( runState != RUNNING || poolSize == 0),
                // 在这个if为true时候，去保证一下任务队列有线程会执行，即执行ensureQueuedTaskHandled(command)方法。
                // 这里有两种情况，情况一：runState != RUNNING，这种情况在ensureQueuedTaskHandled方法中会把任务丢给reject拒绝策略处理，
                // 情况二：poolSize == 0，这种情况是new一个新线程加入到工作线程集合workers中。
                if (runState != RUNNING || poolSize == 0)
                    ensureQueuedTaskHandled(command);
            }
            // 程序执行到这个分支，说明当前状态runState ！= RUNNING，或者任务队列workQueue已经满了。
            // 先看第一个条件下，前面解释过runState，除了RUNNING状态，其他三个状态都不能接收新任务，
            // 所以当runState ！= RUNNING时新任务只能根据reject策略拒绝，
            // 而这个拒绝的逻辑是在addIfUnderMaximumPoolSize方法中实现的；
            // 再看第二个条件下，workQueue已经满，潜在的条件是runState == RUNNING，这种情况怎么处理新任务呢？
            // 很简单，若当前线程数量poolSize没有达到最大线程数量maxPoolSize，
            // 则创建新的线程去执行这个无法加入任务队列的新任务，
            // 否则就根据reject策略拒绝
            else if (!addIfUnderMaximumPoolSize(command))
                reject(command); // is shutdown or saturated
        }
    }

    private Thread addThread(Runnable firstTask) {
        Worker w = new Worker(firstTask);
        // 创建一个新Thread t
        Thread t = threadFactory.newThread(w);
        if (t != null) {
            w.thread = t;
            workers.add(w);
            int nt = ++poolSize;
            // 跟踪线程池大小的最大值
            if (nt > largestPoolSize)
                largestPoolSize = nt;
        }
        return t;
    }

    // 创建并启动新线程执行firstTask（在运行线程数小于核心线程池大小的情况且状态是RUNNING）
    private boolean addIfUnderCorePoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        // 获取锁
        mainLock.lock();
        try {
            if (poolSize < corePoolSize && runState == RUNNING)
                // 创建一个新线程
                t = addThread(firstTask);
        } finally {
            // 释放锁
            mainLock.unlock();
        }
        if (t == null)
            return false;
        // 启动线程执行任务
        t.start();
        return true;
    }

    // 创建并启动新线程执行firstTask（在运行线程数小于pool size的最大值的情况且状态是RUNNING）
    private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
        Thread t = null;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (poolSize < maximumPoolSize && runState == RUNNING)
                t = addThread(firstTask);
        } finally {
            mainLock.unlock();
        }
        if (t == null)
            return false;
        t.start();
        return true;
    }

    // 确保任务被处理
    private void ensureQueuedTaskHandled(Runnable command) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        // 拒绝标记
        boolean reject = false;
        Thread t = null;
        try {
            int state = runState;
            // 如果状态不是RUNNING，能成功从worker队列中移除，则拒绝这个任务执行
            if (state != RUNNING && workQueue.remove(command))
                reject = true;
            else if (state < STOP &&
                     poolSize < Math.max(corePoolSize, 1) &&
                     !workQueue.isEmpty())
                t = addThread(null);
        } finally {
            mainLock.unlock();
        }
        if (reject)
            reject(command);
        else if (t != null)
            // 不用拒绝任务则启动线程执行任务
            t.start();
    }

    // 调用RejectedExecutionHandler决绝任务
    void reject(Runnable command) {
        handler.rejectedExecution(command, this);
    }
    // 工作线程，实现了Runnable接口
    private final class Worker implements Runnable {
        // 每个任务执行都必须获取和释放runLock。这主要是防止中断的目的是取消工作线程，而不是中断正在运行的任务。
        private final ReentrantLock runLock = new ReentrantLock();
        // 要执行的任务
        private Runnable firstTask;
        // 每个线程完成任务的计数器，最后会统计到completedTaskCount中
        volatile long completedTasks;
        // 用于执行Runnable的线程
        Thread thread;
        // 构造方法
        Worker(Runnable firstTask) {
            this.firstTask = firstTask;
        }
        // 判断这个线程是否活动
        boolean isActive() {
            return runLock.isLocked();
        }
        // 中断闲置线程
        void interruptIfIdle() {
            final ReentrantLock runLock = this.runLock;
            if (runLock.tryLock()) {
                try {
            if (thread != Thread.currentThread())
            thread.interrupt();
                } finally {
                    runLock.unlock();
                }
            }
        }
        // 中断
        void interruptNow() {
            thread.interrupt();
        }

        
        private void runTask(Runnable task) {
            final ReentrantLock runLock = this.runLock;
            runLock.lock();
            try {
                
                if (runState < STOP &&
                    Thread.interrupted() &&
                    runState >= STOP)
                    thread.interrupt();
                
                boolean ran = false;
                beforeExecute(thread, task);
                try {
                    task.run();
                    ran = true;
                    afterExecute(task, null);
                    ++completedTasks;
                } catch (RuntimeException ex) {
                    if (!ran)
                        afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                runLock.unlock();
            }
        }

        
        public void run() {
            try {
                Runnable task = firstTask;
                firstTask = null;
                /** 
                 * 注意这段while循环的执行逻辑,每执行完一个核心线程后,就会去线程池 
                 * 队列中取下一个核心线程,如取出的核心线程为null,则当前工作线程终止 
                 */  
                while (task != null || (task = getTask()) != null) {
                    //你所提交的核心线程(任务)的运行逻辑  
                    runTask(task);
                    task = null;
                }
            } finally {
                // 当前工作线程退出  
                workerDone(this);
            }
        }
    }

    // 从池队列中取的核心线程（任务）的方法
    Runnable getTask() {
        for (;;) {
            try {
                // 获取运行状态
                int state = runState;
                // 大于SHUTDOWN，即STOP和TERMINATED状态，没有任务
                if (state > SHUTDOWN)
                    return null;
                Runnable r;
                // SHUTDOWN状态
                if (state == SHUTDOWN)  // 帮助清空队列
                    r = workQueue.poll();
                // 状态时RUNNING，且poolSize > corePoolSize或allowCoreThreadTimeOut
                else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
                    // 获取并移除元素（等待指定的时间）
                    r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
                else
                    // 获取并移除元素（会一直等待知道获取到有效元素）
                    r = workQueue.take();
                // 获取结果不为空，返回
                if (r != null)
                    return r;
                // 检查一个获取任务失败的线程能否退出
                if (workerCanExit()) {
                    if (runState >= SHUTDOWN) // 中断其他线程
                        interruptIdleWorkers();
                    return null;
                }
                // Else retry
            } catch (InterruptedException ie) {
                // On interruption, re-check runState
            }
        }
    }

    // 检查一个获取任务失败的线程能否退出
    private boolean workerCanExit() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        boolean canExit;
        try {
            // 可以退出的条件是状态为STOP或TERMINATED或至少有一个处理非空队列的线程（在允许超时的情况下）
            canExit = runState >= STOP ||
                workQueue.isEmpty() ||
                (allowCoreThreadTimeOut &&
                 poolSize > Math.max(1, corePoolSize));
        } finally {
            mainLock.unlock();
        }
        return canExit;
    }

    // 中断其他线程
    void interruptIdleWorkers() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            // 遍历工作线程
            for (Worker w : workers)
                // 尝试中断闲置线程
                w.interruptIfIdle();
        } finally {
            mainLock.unlock();
        }
    }
    // 工作线程退出要处理的逻辑 
    void workerDone(Worker w) {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            completedTaskCount += w.completedTasks;
            workers.remove(w);//从工作线程缓存中删除  
            if (--poolSize == 0)//poolSize减一,这时其实又可以创建工作线程了  
                tryTerminate();//尝试终止  
        } finally {
            mainLock.unlock();
        }
    }

    // 尝试终止
    private void tryTerminate() {
        //终止的前提条件就是线程池里已经没有工作线程(Worker)了  
        if (poolSize == 0) {
            int state = runState;
            /** 
             * 如果当前已经没有了工作线程(Worker),但是线程队列里还有等待的线程任务,则创建一个 
             * 工作线程来执行线程队列中等待的任务 
             */  
            if (state < STOP && !workQueue.isEmpty()) {
                state = RUNNING; // disable termination check below
                Thread t = addThread(null);
                if (t != null)
                    t.start();
            }
            // 设置池状态为终止状态  
            if (state == STOP || state == SHUTDOWN) {
                runState = TERMINATED;
                termination.signalAll();
                terminated();
            }
        }
    }
    // 发起一个有序的关闭在以前已提交任务的执行，但不接受新任务。如果已经关闭，调用不会有其他影响。
    public void shutdown() {
        // Gets the system security interface.
        SecurityManager security = System.getSecurityManager();
        if (security != null)
            // 检查权限（以抛出异常的形式）
            security.checkPermission(shutdownPerm);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (security != null) { // 检查调用者是否能修改线程
                for (Worker w : workers)
                    security.checkAccess(w.thread);
            }
            // 获取运行状态
            int state = runState;
            // 小于SHUTDOWN的不就是RUNNING么。。。
            if (state < SHUTDOWN)
                runState = SHUTDOWN;

            try {
                for (Worker w : workers) {
                    // 中断线程
                    w.interruptIfIdle();
                }
            } catch (SecurityException se) { // Try to back out
                runState = state;
                // tryTerminate() here would be a no-op
                throw se;
            }
            // 尝试终止
            tryTerminate(); // Terminate now if pool and queue empty
        } finally {
            mainLock.unlock();
        }
    }

    
    public List<Runnable> shutdownNow() {
        SecurityManager security = System.getSecurityManager();
        if (security != null)
            security.checkPermission(shutdownPerm);

        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            if (security != null) { // Check if caller can modify our threads
                for (Worker w : workers)
                    security.checkAccess(w.thread);
            }

            int state = runState;
            // 与上一个方法主要区别在于状态和interruptNow方法
            if (state < STOP)
                runState = STOP;

            try {
                for (Worker w : workers) {
                    w.interruptNow();
                }
            } catch (SecurityException se) { // Try to back out
                runState = state;
                // tryTerminate() here would be a no-op
                throw se;
            }

            List<Runnable> tasks = drainQueue();
            tryTerminate(); // Terminate now if pool and queue empty
            return tasks;
        } finally {
            mainLock.unlock();
        }
    }

    // 清空队列
    private List<Runnable> drainQueue() {
        List<Runnable> taskList = new ArrayList<Runnable>();
        // 将队列中的所有元素一到taskList中
        workQueue.drainTo(taskList);
        while (!workQueue.isEmpty()) {
            Iterator<Runnable> it = workQueue.iterator();
            try {
                if (it.hasNext()) {
                    Runnable r = it.next();
                    // 从workQueue中移除，并添加到taskList中
                    if (workQueue.remove(r))
                        taskList.add(r);
                }
            } catch (ConcurrentModificationException ignore) {
            }
        }
        return taskList;
    }

    public boolean isShutdown() {
        return runState != RUNNING;
    }

    
    boolean isStopped() {
        return runState == STOP;
    }

    
    public boolean isTerminating() {
        int state = runState;
        return state == SHUTDOWN || state == STOP;
    }

    public boolean isTerminated() {
        return runState == TERMINATED;
    }
    
    public boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            for (;;) {
                if (runState == TERMINATED)
                    return true;
                if (nanos <= 0)
                    return false;
                nanos = termination.awaitNanos(nanos);
            }
        } finally {
            mainLock.unlock();
        }
    }

    
    protected void finalize()  {
        shutdown();
    }

    
    public void setThreadFactory(ThreadFactory threadFactory) {
        if (threadFactory == null)
            throw new NullPointerException();
        this.threadFactory = threadFactory;
    }

    
    public ThreadFactory getThreadFactory() {
        return threadFactory;
    }

    
    public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
        if (handler == null)
            throw new NullPointerException();
        this.handler = handler;
    }

    
    public RejectedExecutionHandler getRejectedExecutionHandler() {
        return handler;
    }

    // 设置核心线程数 这里的设置将覆盖构造方法中的设置
    // 如果小于构造方法的设置，多余的线程将被闲置
    // 如果大于构造方法的设置，新线程将被用于执行排队的任务
    public void setCorePoolSize(int corePoolSize) {
        if (corePoolSize < 0)
            throw new IllegalArgumentException();
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int extra = this.corePoolSize - corePoolSize;
            this.corePoolSize = corePoolSize;
            // 大于构造方法的设置
            if (extra < 0) {
                int n = workQueue.size(); 
                while (extra++ < 0 && n-- > 0 && poolSize < corePoolSize) {
                    Thread t = addThread(null);
                    if (t != null)
                        t.start();
                    else
                        break;
                }
            }
            // 小于构造方法的设置
            else if (extra > 0 && poolSize > corePoolSize) {
                try {
                    Iterator<Worker> it = workers.iterator();
                    while (it.hasNext() &&
                           extra-- > 0 &&
                           poolSize > corePoolSize &&
                           workQueue.remainingCapacity() == 0)
                        it.next().interruptIfIdle();
                } catch (SecurityException ignore) {
                    // Not an error; it is OK if the threads stay live
                }
            }
        } finally {
            mainLock.unlock();
        }
    }

    
    public int getCorePoolSize() {
        return corePoolSize;
    }

    
    public boolean prestartCoreThread() {
        return addIfUnderCorePoolSize(null);
    }

    
    public int prestartAllCoreThreads() {
        int n = 0;
        while (addIfUnderCorePoolSize(null))
            ++n;
        return n;
    }

    
    public boolean allowsCoreThreadTimeOut() {
        return allowCoreThreadTimeOut;
    }

    
    public void allowCoreThreadTimeOut(boolean value) {
        if (value && keepAliveTime <= 0)
            throw new IllegalArgumentException("Core threads must have nonzero keep alive times");

        allowCoreThreadTimeOut = value;
    }

    // 设置所允许的最大的线程数。这将覆盖在构造函数中设置的任何值。如果新值小于当前值，多余的现有线程将被终止时，他们成为闲置。
    public void setMaximumPoolSize(int maximumPoolSize) {
        if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
            throw new IllegalArgumentException();
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int extra = this.maximumPoolSize - maximumPoolSize;
            this.maximumPoolSize = maximumPoolSize;
            if (extra > 0 && poolSize > maximumPoolSize) {
                try {
                    Iterator<Worker> it = workers.iterator();
                    while (it.hasNext() &&
                           extra > 0 &&
                           poolSize > maximumPoolSize) {
                        it.next().interruptIfIdle();
                        --extra;
                    }
                } catch (SecurityException ignore) {
                    // Not an error; it is OK if the threads stay live
                }
            }
        } finally {
            mainLock.unlock();
        }
    }

    
    public int getMaximumPoolSize() {
        return maximumPoolSize;
    }

    
    public void setKeepAliveTime(long time, TimeUnit unit) {
        if (time < 0)
            throw new IllegalArgumentException();
        if (time == 0 && allowsCoreThreadTimeOut())
            throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
        this.keepAliveTime = unit.toNanos(time);
    }

    
    public long getKeepAliveTime(TimeUnit unit) {
        return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
    }

    
    public BlockingQueue<Runnable> getQueue() {
        return workQueue;
    }

    
    public boolean remove(Runnable task) {
        return getQueue().remove(task);
    }

    // 移除所有被取消的任务
    public void purge() {
        // Fail if we encounter interference during traversal
        try {
            Iterator<Runnable> it = getQueue().iterator();
            while (it.hasNext()) {
                Runnable r = it.next();
                if (r instanceof Future<?>) {
                    Future<?> c = (Future<?>)r;
                    if (c.isCancelled())
                        it.remove();
                }
            }
        }
        catch (ConcurrentModificationException ex) {
            return;
        }
    }

    
    public int getPoolSize() {
        return poolSize;
    }

    // 获取活跃线程数
    public int getActiveCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            int n = 0;
            for (Worker w : workers) {
                if (w.isActive())
                    ++n;
            }
            return n;
        } finally {
            mainLock.unlock();
        }
    }

    
    public int getLargestPoolSize() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            return largestPoolSize;
        } finally {
            mainLock.unlock();
        }
    }

    
    public long getTaskCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            long n = completedTaskCount;
            for (Worker w : workers) {
                // 统计已经完成的任务
                n += w.completedTasks;
                // 如果w是活跃线程，说明正在执行一个任务，所以n加一
                if (w.isActive())
                    ++n;
            }
            // 加上队列中的任务
            return n + workQueue.size();
        } finally {
            mainLock.unlock();
        }
    }

    // 获取已完成的任务数
    public long getCompletedTaskCount() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            long n = completedTaskCount;
            for (Worker w : workers)
                n += w.completedTasks;
            return n;
        } finally {
            mainLock.unlock();
        }
    }

    
    protected void beforeExecute(Thread t, Runnable r) { }

    
    protected void afterExecute(Runnable r, Throwable t) { }

    
    protected void terminated() { }

    // 实现了RejectedExecutionHandler，即是一个拒绝执行的Handler
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        
        public CallerRunsPolicy() { }

    
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

    
    public static class AbortPolicy implements RejectedExecutionHandler {
        
        public AbortPolicy() { }

        
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException();
        }
    }

    
    public static class DiscardPolicy implements RejectedExecutionHandler {
        
        public DiscardPolicy() { }

        
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

    
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        
        public DiscardOldestPolicy() { }

        
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }
}

    可以参考http://xtu-xiaoxin.iteye.com/blog/647744

    从上面的框架结构图中可以可以看出剩下的就是ScheduledThreadPoolExecutor和Executors。Executors是一个工具类，提供一些工厂和实用方法。

    下面看ScheduledThreadPoolExecutor，它继承自ThreadPoolExecutor并实现了ScheduledExecutorService接口。

    ScheduledThreadPoolExecutor

// 可以安排指定时间或周期性的执行任务的ExecutorService
public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService {
    // 在Shutdown的时候如果要取消或关闭任务，设置为false；true表示继续执行任务，在Shutdown之后
    private volatile boolean continueExistingPeriodicTasksAfterShutdown;
    // false表示在Shutdown的时候取消Delayed的任务；true表示执行这个任务
    private volatile boolean executeExistingDelayedTasksAfterShutdown = true;
    // 打破调度联系，进而保证先进先出的顺序捆绑项目中的序列号
    private static final AtomicLong sequencer = new AtomicLong(0);
    // 基准时间
    private static final long NANO_ORIGIN = System.nanoTime();
    // 当前时间（相对于基准时间的值）
    final long now() {
        return System.nanoTime() - NANO_ORIGIN;
    }
    // RunnableScheduledFuture接口表示是否是周期性的
    private class ScheduledFutureTask<V>
            extends FutureTask<V> implements RunnableScheduledFuture<V> {

        private final long sequenceNumber;
        // 预定安排执行的时刻
        private long time;
        // 表示重复任务，0表示不重复，正数表示固定比率，负数表示固定延时
        private final long period;
        // 构造方法,构造一个只执行一次的任务
        ScheduledFutureTask(Runnable r, V result, long ns) {
            super(r, result);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }
        // 构造方法，构造一个按指定ns开始执行，指定period周期性执行
        ScheduledFutureTask(Runnable r, V result, long ns, long period) {
            super(r, result);
            this.time = ns;
            this.period = period;
            this.sequenceNumber = sequencer.getAndIncrement();
        }
        // 构造方法，构造一个延时执行的任务
        ScheduledFutureTask(Callable<V> callable, long ns) {
            super(callable);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }
        // 按指定单位获取延时时间
        public long getDelay(TimeUnit unit) {
            return unit.convert(time - now(), TimeUnit.NANOSECONDS);
        }
        // 判断传入延时和这个任务延时之间的大小关系
        public int compareTo(Delayed other) {
            // 为什么可以和Delayed比较？因为这个类实现了RunnableScheduledFuture接口，而RunnableScheduledFuture接口继承自Delayed接口
            if (other == this) // compare zero ONLY if same object
                return 0;
            // other是ScheduledFutureTask实例
            if (other instanceof ScheduledFutureTask) {
                ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
                long diff = time - x.time;
                // 比较大小
                if (diff < 0)
                    return -1;
                else if (diff > 0)
                    return 1;
                else if (sequenceNumber < x.sequenceNumber)
                    return -1;
                else
                    return 1;
            }
            long d = (getDelay(TimeUnit.NANOSECONDS) -
                      other.getDelay(TimeUnit.NANOSECONDS));
            return (d == 0)? 0 : ((d < 0)? -1 : 1);
        }
        // 是否周期性的（包括延时的情况）
        public boolean isPeriodic() {
            return period != 0;
        }
        // 执行周期性的任务
        private void runPeriodic() {
            // 执行任务
            boolean ok = ScheduledFutureTask.super.runAndReset();
            // 判断是否已经shutdown
            boolean down = isShutdown();
            // 重新安排任务（如果没有shutdown或在没有关闭且允许在shutdown之后执行已存在的任务）
            if (ok && (!down ||
                       (getContinueExistingPeriodicTasksAfterShutdownPolicy() &&
                        !isStopped()))) {
                long p = period;
                if (p > 0)
                    // 计算下一次执行的时间
                    time += p;
                else
                    // 计算触发时间
                    time = triggerTime(-p);
                // 将任务添加到队列中
                ScheduledThreadPoolExecutor.super.getQueue().add(this);
            }
            else if (down)
                interruptIdleWorkers();
        }
        // 执行任务，根据是否周期性调用不同的方法
        public void run() {
            if (isPeriodic())
                runPeriodic();
            else
                ScheduledFutureTask.super.run();
        }
    }
    // 延迟执行
    private void delayedExecute(Runnable command) {
        // 如果已经shutdown，决绝任务
        if (isShutdown()) {
            reject(command);
            return;
        }
        if (getPoolSize() < getCorePoolSize())
            // 预启动线程
            prestartCoreThread();

        super.getQueue().add(command);
    }

    // 取消和清除关闭政策不允许运行的任务
    private void cancelUnwantedTasks() {
        // 获取shutdown策略
        boolean keepDelayed = getExecuteExistingDelayedTasksAfterShutdownPolicy();
        boolean keepPeriodic = getContinueExistingPeriodicTasksAfterShutdownPolicy();
        if (!keepDelayed && !keepPeriodic)
            super.getQueue().clear();
        else if (keepDelayed || keepPeriodic) {
            Object[] entries = super.getQueue().toArray();
            for (int i = 0; i < entries.length; ++i) {
                Object e = entries[i];
                if (e instanceof RunnableScheduledFuture) {
                    RunnableScheduledFuture<?> t = (RunnableScheduledFuture<?>)e;
                    // 根据是否周期性的任务通过制定的值判断进行取消操作
                    if (t.isPeriodic()? !keepPeriodic : !keepDelayed)
                        t.cancel(false);
                }
            }
            entries = null;
            // 净化，移除已经取消的任务
            purge();
        }
    }

    public boolean remove(Runnable task) {
        if (!(task instanceof RunnableScheduledFuture))
            return false;
        return getQueue().remove(task);
    }

    protected <V> RunnableScheduledFuture<V> decorateTask(
        Runnable runnable, RunnableScheduledFuture<V> task) {
        return task;
    }

    protected <V> RunnableScheduledFuture<V> decorateTask(
        Callable<V> callable, RunnableScheduledFuture<V> task) {
        return task;
    }

    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue());
    }

    public ScheduledThreadPoolExecutor(int corePoolSize,
                             ThreadFactory threadFactory) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
    }

    public ScheduledThreadPoolExecutor(int corePoolSize,
                              RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue(), handler);
    }

    private long triggerTime(long delay, TimeUnit unit) {
         return triggerTime(unit.toNanos((delay < 0) ? 0 : delay));
    }

    long triggerTime(long delay) {
         return now() +
             ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
    }
    // 避免移除，返回延迟的值
    private long overflowFree(long delay) {
        Delayed head = (Delayed) super.getQueue().peek();
        if (head != null) {
            long headDelay = head.getDelay(TimeUnit.NANOSECONDS);
            if (headDelay < 0 && (delay - headDelay < 0))
                delay = Long.MAX_VALUE + headDelay;
        }
        return delay;
    }
 
    public ScheduledThreadPoolExecutor(int corePoolSize,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
              new DelayedWorkQueue(), threadFactory, handler);
    }
    // 根据执行的延时时间执行任务
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay,
                                       TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        // ScheduledFutureTask的result为null
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Void>(command, null,
                                          triggerTime(delay, unit)));
        // 延时执行
        delayedExecute(t);
        return t;
    }
    // 上一个方法的重载形式，接收的是Callable
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay,
                                           TimeUnit unit) {
        if (callable == null || unit == null)
            throw new NullPointerException();
        RunnableScheduledFuture<V> t = decorateTask(callable,
            new ScheduledFutureTask<V>(callable,
                          triggerTime(delay, unit)));
        delayedExecute(t);
        return t;
    }
    /**
     * 创建并执行一个周期性的任务，在initialDelay延迟后每间隔period个单位执行一次，时间单位都是unit
     * 每次执行任务的时间点是initialDelay, initialDelay+period, initialDelay + 2 * period...
     */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0)
            throw new IllegalArgumentException();
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Object>(command,
                                            null,
                                            triggerTime(initialDelay, unit),
                                            unit.toNanos(period)));
        delayedExecute(t);
        return t;
    }
    /**
     * 创建并执行一个周期性的任务，在initialDelay延迟后开始执行，在执行结束后再延迟delay个单位开始执行下一次任务，时间单位都是unit
     * 每次执行任务的时间点是initialDelay, initialDelay+(任务运行时间+delay), initialDelay + 2 * (任务运行时间+delay)...
     */
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0)
            throw new IllegalArgumentException();
        RunnableScheduledFuture<?> t = decorateTask(command,
            new ScheduledFutureTask<Boolean>(command,
                                             null,
                                             triggerTime(initialDelay, unit),
                                             unit.toNanos(-delay)));
        delayedExecute(t);
        return t;
    }


    // 执行任务
    public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        // 立即执行，延时时间是0
        schedule(command, 0, TimeUnit.NANOSECONDS);
    }

    // 重新 AbstractExecutorService 的方法

    public Future<?> submit(Runnable task) {
        return schedule(task, 0, TimeUnit.NANOSECONDS);
    }

    public <T> Future<T> submit(Runnable task, T result) {
        return schedule(Executors.callable(task, result),
                        0, TimeUnit.NANOSECONDS);
    }

    public <T> Future<T> submit(Callable<T> task) {
        return schedule(task, 0, TimeUnit.NANOSECONDS);
    }

    
    public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) {
        continueExistingPeriodicTasksAfterShutdown = value;
        if (!value && isShutdown())
            cancelUnwantedTasks();
    }

    
    public boolean getContinueExistingPeriodicTasksAfterShutdownPolicy() {
        return continueExistingPeriodicTasksAfterShutdown;
    }

   
    public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) {
        executeExistingDelayedTasksAfterShutdown = value;
        if (!value && isShutdown())
            cancelUnwantedTasks();
    }

    
    public boolean getExecuteExistingDelayedTasksAfterShutdownPolicy() {
        return executeExistingDelayedTasksAfterShutdown;
    }


    // 关闭
    public void shutdown() {
        // 取消任务
        cancelUnwantedTasks();
        super.shutdown();
    }

    // 立即关闭，调用的是父类立即关闭的方法
    public List<Runnable> shutdownNow() {
        return super.shutdownNow();
    }

    // 返回使用这个执行器的任务队列
    public BlockingQueue<Runnable> getQueue() {
        return super.getQueue();
    }

    // 将DelayQueue<RunnableScheduledFuture> 包装为 BlockingQueue<Runnable>的类
    // 类似于代理
    private static class DelayedWorkQueue
        extends AbstractCollection<Runnable>
        implements BlockingQueue<Runnable> {

        private final DelayQueue<RunnableScheduledFuture> dq = new DelayQueue<RunnableScheduledFuture>();
        public Runnable poll() { return dq.poll(); }
        public Runnable peek() { return dq.peek(); }
        public Runnable take() throws InterruptedException { return dq.take(); }
        public Runnable poll(long timeout, TimeUnit unit) throws InterruptedException {
            return dq.poll(timeout, unit);
        }

        public boolean add(Runnable x) {
        return dq.add((RunnableScheduledFuture)x);
    }
        public boolean offer(Runnable x) {
        return dq.offer((RunnableScheduledFuture)x);
    }
        public void put(Runnable x) {
            dq.put((RunnableScheduledFuture)x);
        }
        public boolean offer(Runnable x, long timeout, TimeUnit unit) {
            return dq.offer((RunnableScheduledFuture)x, timeout, unit);
        }

        public Runnable remove() { return dq.remove(); }
        public Runnable element() { return dq.element(); }
        public void clear() { dq.clear(); }
        public int drainTo(Collection<? super Runnable> c) { return dq.drainTo(c); }
        public int drainTo(Collection<? super Runnable> c, int maxElements) {
            return dq.drainTo(c, maxElements);
        }

        public int remainingCapacity() { return dq.remainingCapacity(); }
        public boolean remove(Object x) { return dq.remove(x); }
        public boolean contains(Object x) { return dq.contains(x); }
        public int size() { return dq.size(); }
        public boolean isEmpty() { return dq.isEmpty(); }
        public Object[] toArray() { return dq.toArray(); }
        public <T> T[] toArray(T[] array) { return dq.toArray(array); }
        public Iterator<Runnable> iterator() {
            return new Iterator<Runnable>() {
                private Iterator<RunnableScheduledFuture> it = dq.iterator();
                public boolean hasNext() { return it.hasNext(); }
                public Runnable next() { return it.next(); }
                public void remove() { it.remove(); }
            };
        }
    }
}

    在代码中都加了注释，我想大致能解释清楚吧。

    Executor涉及的类还是比较多的，到此为止剩下的还有Executors

    Executors

    Executors中所定义的 Executor、ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 类的工厂和实用方法。此类支持以下各种方法：

• 创建并返回设置有常用配置字符串的 ExecutorService 的方法。
• 创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。
• 创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。
• 创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。
• 创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。 

     Executors提供的都是工具形式的方法，所以都是static的，并且这个类也没有必要实例化，所以它的构造方法时private的。下面主要看一下几个内部类。

　  RunnableAdapter

static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable  task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
}

    适配器。以Callable的形式执行Runnable并且返回给定的result。

    PrivilegedCallable

static final class PrivilegedCallable<T> implements Callable<T> {
    private final AccessControlContext acc;
    private final Callable<T> task;
    private T result;
    private Exception exception;
    PrivilegedCallable(Callable<T> task) {
        this.task = task;
        this.acc = AccessController.getContext();
    }

    public T call() throws Exception {
        AccessController.doPrivileged(new PrivilegedAction<T>() {
            public T run() {
                try {
                    result = task.call();
                } catch (Exception ex) {
                    exception = ex;
                }
                return null;
            }
        }, acc);
        if (exception != null)
            throw exception;
        else
            return result;
    }
}

    在访问控制下运行的Callable。涉及到Java.security包中的内容。

    PrivilegedCallableUsingCurrentClassLoader类与上面的PrivilegedCallable类似，只是使用的是CurrentClassLoader。

    DefaultThreadFactory

    static class DefaultThreadFactory implements ThreadFactory {
        static final AtomicInteger poolNumber = new AtomicInteger(1);
        final ThreadGroup group;
        final AtomicInteger threadNumber = new AtomicInteger(1);
        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构造方法创建线程
            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;
        }
    }

    DefaultThreadFactory 是默认的线程工程，提供创建线程的方法。

    PrivilegedThreadFactory继承自DefaultThreadFactory，区别在于线程执行的run方法指定了classLoader并受到权限的控制。

    DelegatedExecutorService继承自AbstractExecutorService，是一个包装类，暴露ExecutorService的方法。

    DelegatedScheduledExecutorService继承自DelegatedExecutorService，实现了ScheduledExecutorService接口。它也是一个包装类，公开ScheduledExecutorService方法。