Java Executor 框架-阿里云开发者社区

开发者社区> 蘑菇街隐修> 正文

Java Executor 框架

简介: Executor框架是指java5中引入的一系列并发库中与executor相关的功能类,包括Executor、Executors、ExecutorService、CompletionService、Future、Callable等。
+关注继续查看

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

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

     Executor

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

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

     ExecutorService

 1 //继承自Executor接口
 2 public interface ExecutorService extends Executor {
 3     /**
 4      * 关闭方法,调用后执行之前提交的任务,不再接受新的任务
 5      */
 6     void shutdown();
 7     /**
 8      * 从语义上可以看出是立即停止的意思,将暂停所有等待处理的任务并返回这些任务的列表
 9      */
10     List<Runnable> shutdownNow();
11     /**
12      * 判断执行器是否已经关闭
13      */
14     boolean isShutdown();
15     /**
16      * 关闭后所有任务是否都已完成
17      */
18     boolean isTerminated();
19     /**
20      * 中断
21      */
22     boolean awaitTermination(long timeout, TimeUnit unit)
23         throws InterruptedException;
24     /**
25      * 提交一个Callable任务
26      */
27     <T> Future<T> submit(Callable<T> task);
28     /**
29      * 提交一个Runable任务,result要返回的结果
30      */
31     <T> Future<T> submit(Runnable task, T result);
32     /**
33      * 提交一个任务
34      */
35     Future<?> submit(Runnable task);
36     /**
37      * 执行所有给定的任务,当所有任务完成,返回保持任务状态和结果的Future列表
38      */
39     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
40         throws InterruptedException;
41     /**
42      * 执行给定的任务,当所有任务完成或超时期满时(无论哪个首先发生),返回保持任务状态和结果的 Future 列表。
43      */
44     <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
45                                   long timeout, TimeUnit unit)
46         throws InterruptedException;
47     /**
48      * 执行给定的任务,如果某个任务已成功完成(也就是未抛出异常),则返回其结果。
49      */
50     <T> T invokeAny(Collection<? extends Callable<T>> tasks)
51         throws InterruptedException, ExecutionException;
52     /**
53      * 执行给定的任务,如果在给定的超时期满前某个任务已成功完成(也就是未抛出异常),则返回其结果。
54      */
55     <T> T invokeAny(Collection<? extends Callable<T>> tasks,
56                     long timeout, TimeUnit unit)
57         throws InterruptedException, ExecutionException, TimeoutException;
58 }

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

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

 1 // 实现Runnable接口的类将被Thread执行,表示一个基本的任务
 2 public interface Runnable {
 3     // run方法就是它所有的内容,就是实际执行的任务
 4     public abstract void run();
 5 }
 6 // Callable同样是任务,与Runnable接口的区别在于它接收泛型,同时它执行任务后带有返回内容
 7 public interface Callable<V> {
 8     // 相对于run方法的带有返回值的call方法
 9     V call() throws Exception;
10 }
Future
 1 // Future代表异步任务的执行结果
 2 public interface Future<V> {
 3 
 4     /**
 5      * 尝试取消一个任务,如果这个任务不能被取消(通常是因为已经执行完了),返回false,否则返回true。
 6      */
 7     boolean cancel(boolean mayInterruptIfRunning);
 8 
 9     /**
10      * 返回代表的任务是否在完成之前被取消了
11      */
12     boolean isCancelled();
13 
14     /**
15      * 如果任务已经完成,返回true
16      */
17     boolean isDone();
18 
19     /**
20      * 获取异步任务的执行结果(如果任务没执行完将等待)
21      */
22     V get() throws InterruptedException, ExecutionException;
23 
24     /**
25      * 获取异步任务的执行结果(有最常等待时间的限制)
26      *
27      *  timeout表示等待的时间,unit是它时间单位
28      */
29     V get(long timeout, TimeUnit unit)
30         throws InterruptedException, ExecutionException, TimeoutException;
31 }

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

     ScheduledExecutorService

 1 // 可以安排指定时间或周期性的执行任务的ExecutorService
 2 public interface ScheduledExecutorService extends ExecutorService {
 3     /**
 4      * 在指定延迟后执行一个任务,只执行一次
 5      */
 6     public ScheduledFuture<?> schedule(Runnable command,
 7                        long delay, TimeUnit unit);
 8     /**
 9      * 与上面的方法相同,只是接受的是Callable任务
10      */
11     public <V> ScheduledFuture<V> schedule(Callable<V> callable,
12                        long delay, TimeUnit unit);
13     /**
14      * 创建并执行一个周期性的任务,在initialDelay延迟后每间隔period个单位执行一次,时间单位都是unit
15      * 每次执行任务的时间点是initialDelay, initialDelay+period, initialDelay + 2 * period...
16      */
17     public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
18                           long initialDelay,
19                           long period,
20                           TimeUnit unit);
21     /**
22      * 创建并执行一个周期性的任务,在initialDelay延迟后开始执行,在执行结束后再延迟delay个单位开始执行下一次任务,时间单位都是unit
23      * 每次执行任务的时间点是initialDelay, initialDelay+(任务运行时间+delay), initialDelay + 2 * (任务运行时间+delay)...
24      */
25     public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
26                              long initialDelay,
27                              long delay,
28                              TimeUnit unit);
29 }

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

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

     AbstractExecutorService

  1 // 提供ExecutorService的默认实现
  2 public abstract class AbstractExecutorService implements ExecutorService {
  3     /*
  4      * 为指定的Runnable和value构造一个FutureTask,value表示默认被返回的Future
  5      */
  6     protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
  7         return new FutureTask<T>(runnable, value);
  8     }
  9     /*
 10      * 为指定的Callable创建一个FutureTask
 11      */
 12     protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
 13         return new FutureTask<T>(callable);
 14     }
 15     /*
 16      * 提交Runnable任务
 17      */
 18     public Future<?> submit(Runnable task) {
 19         if (task == null) throw new NullPointerException();
 20         // 通过newTaskFor方法构造RunnableFuture,默认的返回值是null
 21         RunnableFuture<Object> ftask = newTaskFor(task, null);
 22         // 调用具体实现的execute方法
 23         execute(ftask);
 24         return ftask;
 25     }
 26     /*
 27      * 提交Runnable任务
 28      */
 29     public <T> Future<T> submit(Runnable task, T result) {
 30         if (task == null) throw new NullPointerException();
 31         // 通过newTaskFor方法构造RunnableFuture,默认的返回值是result
 32         RunnableFuture<T> ftask = newTaskFor(task, result);
 33         execute(ftask);
 34         return ftask;
 35     }
 36     /*
 37      * 提交Callable任务
 38      */
 39     public <T> Future<T> submit(Callable<T> task) {
 40         if (task == null) throw new NullPointerException();
 41         RunnableFuture<T> ftask = newTaskFor(task);
 42         execute(ftask);
 43         return ftask;
 44     }
 45 
 46     /*
 47      * doInvokeAny的具体实现(核心内容),其它几个方法都是重载方法,都对这个方法进行调用
 48      * tasks 是被执行的任务集,timed标志是否定时的,nanos表示定时的情况下执行任务的限制时间
 49      */
 50     private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
 51                             boolean timed, long nanos)
 52         throws InterruptedException, ExecutionException, TimeoutException {
 53         // tasks空判断
 54         if (tasks == null)
 55             throw new NullPointerException();
 56         // 任务数量
 57         int ntasks = tasks.size();
 58         if (ntasks == 0)
 59             throw new IllegalArgumentException();
 60         // 创建对应数量的Future返回集
 61         List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
 62         ExecutorCompletionService<T> ecs =
 63             new ExecutorCompletionService<T>(this);
 64         try {
 65             // 执行异常
 66             ExecutionException ee = null;
 67             // System.nanoTime()根据系统计时器当回当前的纳秒值
 68             long lastTime = (timed)? System.nanoTime() : 0;
 69             // 获取任务集的遍历器
 70             Iterator<? extends Callable<T>> it = tasks.iterator();
 71 
 72             // 向执行器ExecutorCompletionService提交一个任务,并将结果加入futures中
 73             futures.add(ecs.submit(it.next
 74             // 修改任务计数器
 75             --ntasks;
 76             // 活跃任务计数器
 77             int active = 1;
 78             for (;;) {
 79                 // 获取并移除代表已完成任务的Future,如果不存在,返回null
 80                 Future<T> f = ecs.poll();
 81                 if (f == null) {
 82                     // 没有任务完成,且任务集中还有未提交的任务
 83                     if (ntasks > 0) {
 84                         // 剩余任务计数器减1
 85                         --ntasks;
 86                         // 提交任务并添加结果
 87                         futures.add(ecs.submit(it.next()));
 88                         // 活跃任务计数器加1
 89                         ++active;
 90                     }
 91                     // 没有剩余任务,且没有活跃任务(所有任务可能都会取消),跳过这一次循环
 92                     else if (active == 0)
 93                         break;
 94                     else if (timed) {
 95                         // 获取并移除代表已完成任务的Future,如果不存在,会等待nanos指定的纳秒数
 96                         f = ecs.poll(nanos, TimeUnit.NANOSECONDS);
 97                         if (f == null)
 98                             throw new TimeoutException();
 99                         // 计算剩余可用时间
100                         long now = System.nanoTime();
101                         nanos -= now - lastTime;
102                         lastTime = now;
103                     }
104                     else
105                         // 获取并移除表示下一个已完成任务的未来,等待,如果目前不存在。
106                         // 执行到这一步说明已经没有任务任务可以提交,只能等待某一个任务的返回
107                         f = ecs.take();
108                 }
109                 // f不为空说明有一个任务完成了
110                 if (f != null) {
111                     // 已完成一个任务,所以活跃任务计数减1
112                     --active;
113                     try {
114                         // 返回该任务的结果
115                         return f.get();
116                     } catch (InterruptedException ie) {
117                         throw ie;
118                     } catch (ExecutionException eex) {
119                         ee = eex;
120                     } catch (RuntimeException rex) {
121                         ee = new ExecutionException(rex);
122                     }
123                 }
124             }
125             // 如果没有成功返回结果则抛出异常
126             if (ee == null)
127                 ee = new ExecutionException();
128             throw ee;
129 
130         } finally {
131             // 无论执行中发生异常还是顺利结束,都将取消剩余未执行的任务
132             for (Future<T> f : futures)
133                 f.cancel(true);
134         }
135     }
136 
137     public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
138         throws InterruptedException, ExecutionException {
139         try {
140             // 非定时任务的doInvokeAny调用
141             return doInvokeAny(tasks, false, 0);
142         } catch (TimeoutException cannotHappen) {
143             assert false;
144             return null;
145         }
146     }
147     // 定时任务的invokeAny调用,timeout表示超时时间,unit表示时间单位
148     public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
149                            long timeout, TimeUnit unit)
150         throws InterruptedException, ExecutionException, TimeoutException {
151         return doInvokeAny(tasks, true, unit.toNanos(timeout));
152     }
153     // 无超时设置的invokeAll方法
154     public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
155         throws InterruptedException {
156         // 空任务判断
157         if (tasks == null)
158             throw new NullPointerException();
159         // 创建大小为任务数量的结果集
160         List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
161         // 是否完成所有任务的标记
162         boolean done = false;
163         try {
164             // 遍历并执行任务
165             for (Callable<T> t : tasks) {
166                 RunnableFuture<T> f = newTaskFor(t);
167                 futures.add(f);
168                 execute(f);
169             }
170             // 遍历结果集
171             for (Future<T> f : futures) {
172                 // 如果某个任务没完成,通过f调用get()方法
173                 if (!f.isDone()) {
174                     try {
175                         // get方法等待计算完成,然后获取结果(会等待)。所以调用get后任务就会完成计算,否则会等待
176                         f.get();
177                     } catch (CancellationException ignore) {
178                     } catch (ExecutionException ignore) {
179                     }
180                 }
181             }
182             // 标志所有任务执行完成
183             done = true;
184             // 返回结果
185             return futures;
186         } finally {
187             // 假如没有完成所有任务(可能是发生异常等情况),将任务取消
188             if (!done)
189                 for (Future<T> f : futures)
190                     f.cancel(true);
191         }
192     }
193     // 超时设置的invokeAll方法
194     public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
195                                          long timeout, TimeUnit unit)
196         throws InterruptedException {
197         // 需要执行的任务集为空或时间单位为空,抛出异常
198         if (tasks == null || unit == null)
199             throw new NullPointerException();
200         // 将超时时间转为纳秒单位
201         long nanos = unit.toNanos(timeout);
202         // 创建任务结果集
203         List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
204         // 是否全部完成的标志
205         boolean done = false;
206         try {
207             // 遍历tasks,将任务转为RunnableFuture
208             for (Callable<T> t : tasks)
209                 futures.add(newTaskFor(t));
210             // 记录当前时间(单位是纳秒)
211             long lastTime = System.nanoTime();
212             // 获取迭代器
213             Iterator<Future<T>> it = futures.iterator();
214             // 遍历
215             while (it.hasNext()) {
216                 // 执行任务
217                 execute((Runnable)(it.next()));
218                 // 记录当前时间
219                 long now = System.nanoTime();
220                 // 计算剩余可用时间
221                 nanos -= now - lastTime;
222                 // 更新上一次执行时间
223                 lastTime = now;
224                 // 超时,返回保存任务状态的结果集
225                 if (nanos <= 0)
226                     return futures;
227             }
228 
229             for (Future<T> f : futures) {
230                 // 如果有任务没完成
231                 if (!f.isDone()) {
232                     // 时间已经用完,返回保存任务状态的结果集
233                     if (nanos <= 0)
234                         return futures;
235                     try {
236                         // 获取计算结果,最多等待给定的时间nanos,单位是纳秒
237                         f.get(nanos, TimeUnit.NANOSECONDS);
238                     } catch (CancellationException ignore) {
239                     } catch (ExecutionException ignore) {
240                     } catch (TimeoutException toe) {
241                         return futures;
242                     }
243                     // 计算可用时间
244                     long now = System.nanoTime();
245                     nanos -= now - lastTime;
246                     lastTime = now;
247                 }
248             }
249             // 修改是否全部完成的标记
250             done = true;
251             // 返回结果集
252             return futures;
253         } finally {
254             // 假如没有完成所有任务(可能是时间已经用完、发生异常等情况),将任务取消
255             if (!done)
256                 for (Future<T> f : futures)
257                     f.cancel(true);
258         }
259     }
260 }

    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

ThreadPoolExecutor(好长)
  1 public class ThreadPoolExecutor extends AbstractExecutorService {
  2     // 检查关闭的权限        
  3     private static final RuntimePermission shutdownPerm =
  4         new RuntimePermission("modifyThread");
  5     /* runState提供了主要的生命周期控制,可取值有以下几个:
  6      * RUNNING:接受新的任务,处理队列中的任务
  7      * SHUTDOWN:不再接受新的任务,但是处理队列中的任务
  8      * STOP:不接受新任务,也不处理队列中的任务,打断正在处理的任务
  9      * TERMINATED:和STOP类似,同时终止所有线程
 10      * RUNNING -> SHUTDOWN
 11      *    On invocation of shutdown(), perhaps implicitly in finalize()
 12      * (RUNNING or SHUTDOWN) -> STOP
 13      *    On invocation of shutdownNow()
 14      * SHUTDOWN -> TERMINATED
 15      *    When both queue and pool are empty
 16      * STOP -> TERMINATED
 17      *    When pool is empty
 18      * 
 19      */
 20     volatile int runState;
 21     static final int RUNNING    = 0;
 22     static final int SHUTDOWN   = 1;
 23     static final int STOP       = 2;
 24     static final int TERMINATED = 3;
 25 
 26     // 用于保持任务的队列
 27     private final BlockingQueue<Runnable> workQueue;
 28     // poolSize, corePoolSize, maximumPoolSize, runState, workers set的更新锁
 29     private final ReentrantLock mainLock = new ReentrantLock();
 30     // mainLock锁的一个Condition实例
 31     private final Condition termination = mainLock.newCondition();
 32     // 保持线程池中所有的工作线程。只有获取mainLock锁后才能访问。
 33     private final HashSet<Worker> workers = new HashSet<Worker>();
 34     // 空闲线程的等待时间,大为是纳秒
 35     private volatile long  keepAliveTime;
 36     // 是否允许核心线程“活着” false(默认值)允许,哪怕空闲;true则使用keepAliveTime来控制等待超时时间
 37     private volatile boolean allowCoreThreadTimeOut;
 38     // 核心线程池的大小
 39     private volatile int   corePoolSize;
 40     // pool size最大值
 41     private volatile int   maximumPoolSize;
 42     // 当前pool大小
 43     private volatile int   poolSize;
 44     // 拒绝执行的处理器 顾名思义,当一个任务被拒绝执行后将同个这个处理器进行处理
 45     private volatile RejectedExecutionHandler handler;
 46     // 线程工厂,用于创建线程
 47     private volatile ThreadFactory threadFactory;
 48     // 最终pool size达到的最大值
 49     private int largestPoolSize;
 50     // 已完成任务计数
 51     private long completedTaskCount;
 52     // 默认的拒绝执行的处理器
 53     private static final RejectedExecutionHandler defaultHandler =
 54         new AbortPolicy();
 55     /**
 56      * 关于借个size的说明:
 57      * 线程池数量poolSize指工作线程Worker对象的集合workers的实际大小,通过workers.size()可直接获得。            
 58      * 核心线程池数量corePoolSize,可理解为工作线程Worker对象的集合workers的目标大小。
 59      * 如果poolSize > corePoolSize,那么ThreadPoolExecutor就会有机制在适当的时候回收闲置的线程。
 60      * 最大线程池数量maxPoolSize,就是工作线程Worker对象的集合workers的大小上限。
 61      * 假如说任务队列满了,再来新任务时,若poolSize还没达到maxPoolSize,则继续创建新的线程来执行新任务,
 62      * 若不幸poolSize达到了上限maxPoolSize,那不能再创建新的线程了,只能采取reject策略来拒绝新任务。
 63      */
 64     /** 构造方法 开始*/
 65     public ThreadPoolExecutor(int corePoolSize,
 66                               int maximumPoolSize,
 67                               long keepAliveTime,
 68                               TimeUnit unit,
 69                               BlockingQueue<Runnable> workQueue) {
 70         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
 71              Executors.defaultThreadFactory(), defaultHandler);
 72     }
 73     public ThreadPoolExecutor(int corePoolSize,
 74                               int maximumPoolSize,
 75                               long keepAliveTime,
 76                               TimeUnit unit,
 77                               BlockingQueue<Runnable> workQueue,
 78                               ThreadFactory threadFactory) {
 79         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
 80              threadFactory, defaultHandler);
 81     }
 82     public ThreadPoolExecutor(int corePoolSize,
 83                               int maximumPoolSize,
 84                               long keepAliveTime,
 85                               TimeUnit unit,
 86                               BlockingQueue<Runnable> workQueue,
 87                               RejectedExecutionHandler handler) {
 88         this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
 89              Executors.defaultThreadFactory(), handler);
 90     }
 91     // 主要的构造方法,其它构造方法都是对这个方法的调用
 92     public ThreadPoolExecutor(int corePoolSize,
 93                               int maximumPoolSize,
 94                               long keepAliveTime,
 95                               TimeUnit unit,
 96                               BlockingQueue<Runnable> workQueue,
 97                               ThreadFactory threadFactory,
 98                               RejectedExecutionHandler handler) {
 99         // 非法输入(明显这些值都是不能小于0的)
100         if (corePoolSize < 0 ||
101             maximumPoolSize <= 0 ||
102             maximumPoolSize < corePoolSize ||
103             keepAliveTime < 0)
104             throw new IllegalArgumentException();
105         // 空判断
106         if (workQueue == null || threadFactory == null || handler == null)
107             throw new NullPointerException();
108         this.corePoolSize = corePoolSize;
109         this.maximumPoolSize = maximumPoolSize;
110         this.workQueue = workQueue;
111         this.keepAliveTime = unit.toNanos(keepAliveTime);
112         this.threadFactory = threadFactory;
113         this.handler = handler;
114     }
115     /** 构造方法 结束*/
116     
117 
118     // 执行Runnable任务
119     public void execute(Runnable command) {
120         if (command == null)
121             throw new NullPointerException();
122             /*如果当前线程数量poolSize>=核心线程数量corePoolSize,
123             那当然无法再把当前任务加入到核心线程池中执行了,于是进花括号选择其他的策略执行;
124             如果poolSize没有达到corePoolSize,那很自然是把当前任务放到核心线程池执行,
125             也就是执行逻辑或运算符后的方法addIfUnderCorePoolSize(command)。
126             “放到核心线程池执行”是什么意思呢?
127             就是new 一个新工作线程放到workers集合中,让这个新线程来执行当前的任务command,而这个新线程可以认为是核心线程池中的其中一个线程。*/
128         if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
129             // 线程池状态时RUNNING且能将任务添加到worker队列中
130             if (runState == RUNNING && workQueue.offer(command)) {
131                 // 加入了队列以后,只要保证有工作线程就ok了,工作线程会自动去执行任务队列的。
132                 // 所以判断一下if ( runState != RUNNING || poolSize == 0),
133                 // 在这个if为true时候,去保证一下任务队列有线程会执行,即执行ensureQueuedTaskHandled(command)方法。
134                 // 这里有两种情况,情况一:runState != RUNNING,这种情况在ensureQueuedTaskHandled方法中会把任务丢给reject拒绝策略处理,
135                 // 情况二:poolSize == 0,这种情况是new一个新线程加入到工作线程集合workers中。
136                 if (runState != RUNNING || poolSize == 0)
137                     ensureQueuedTaskHandled(command);
138             }
139             // 程序执行到这个分支,说明当前状态runState != RUNNING,或者任务队列workQueue已经满了。
140             // 先看第一个条件下,前面解释过runState,除了RUNNING状态,其他三个状态都不能接收新任务,
141             // 所以当runState != RUNNING时新任务只能根据reject策略拒绝,
142             // 而这个拒绝的逻辑是在addIfUnderMaximumPoolSize方法中实现的;
143             // 再看第二个条件下,workQueue已经满,潜在的条件是runState == RUNNING,这种情况怎么处理新任务呢?
144             // 很简单,若当前线程数量poolSize没有达到最大线程数量maxPoolSize,
145             // 则创建新的线程去执行这个无法加入任务队列的新任务,
146             // 否则就根据reject策略拒绝
147             else if (!addIfUnderMaximumPoolSize(command))
148                 reject(command); // is shutdown or saturated
149         }
150     }
151 
152     private Thread addThread(Runnable firstTask) {
153         Worker w = new Worker(firstTask);
154         // 创建一个新Thread t
155         Thread t = threadFactory.newThread(w);
156         if (t != null) {
157             w.thread = t;
158             workers.add(w);
159             int nt = ++poolSize;
160             // 跟踪线程池大小的最大值
161             if (nt > largestPoolSize)
162                 largestPoolSize = nt;
163         }
164         return t;
165     }
166 
167     // 创建并启动新线程执行firstTask(在运行线程数小于核心线程池大小的情况且状态是RUNNING)
168     private boolean addIfUnderCorePoolSize(Runnable firstTask) {
169         Thread t = null;
170         final ReentrantLock mainLock = this.mainLock;
171         // 获取锁
172         mainLock.lock();
173         try {
174             if (poolSize < corePoolSize && runState == RUNNING)
175                 // 创建一个新线程
176                 t = addThread(firstTask);
177         } finally {
178             // 释放锁
179             mainLock.unlock();
180         }
181         if (t == null)
182             return false;
183         // 启动线程执行任务
184         t.start();
185         return true;
186     }
187 
188     // 创建并启动新线程执行firstTask(在运行线程数小于pool size的最大值的情况且状态是RUNNING)
189     private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
190         Thread t = null;
191         final ReentrantLock mainLock = this.mainLock;
192         mainLock.lock();
193         try {
194             if (poolSize < maximumPoolSize && runState == RUNNING)
195                 t = addThread(firstTask);
196         } finally {
197             mainLock.unlock();
198         }
199         if (t == null)
200             return false;
201         t.start();
202         return true;
203     }
204 
205     // 确保任务被处理
206     private void ensureQueuedTaskHandled(Runnable command) {
207         final ReentrantLock mainLock = this.mainLock;
208         mainLock.lock();
209         // 拒绝标记
210         boolean reject = false;
211         Thread t = null;
212         try {
213             int state = runState;
214             // 如果状态不是RUNNING,能成功从worker队列中移除,则拒绝这个任务执行
215             if (state != RUNNING && workQueue.remove(command))
216                 reject = true;
217             else if (state < STOP &&
218                      poolSize < Math.max(corePoolSize, 1) &&
219                      !workQueue.isEmpty())
220                 t = addThread(null);
221         } finally {
222             mainLock.unlock();
223         }
224         if (reject)
225             reject(command);
226         else if (t != null)
227             // 不用拒绝任务则启动线程执行任务
228             t.start();
229     }
230 
231     // 调用RejectedExecutionHandler决绝任务
232     void reject(Runnable command) {
233         handler.rejectedExecution(command, this);
234     }
235     // 工作线程,实现了Runnable接口
236     private final class Worker implements Runnable {
237         // 每个任务执行都必须获取和释放runLock。这主要是防止中断的目的是取消工作线程,而不是中断正在运行的任务。
238         private final ReentrantLock runLock = new ReentrantLock();
239         // 要执行的任务
240         private Runnable firstTask;
241         // 每个线程完成任务的计数器,最后会统计到completedTaskCount中
242         volatile long completedTasks;
243         // 用于执行Runnable的线程
244         Thread thread;
245         // 构造方法
246         Worker(Runnable firstTask) {
247             this.firstTask = firstTask;
248         }
249         // 判断这个线程是否活动
250         boolean isActive() {
251             return runLock.isLocked();
252         }
253         // 中断闲置线程
254         void interruptIfIdle() {
255             final ReentrantLock runLock = this.runLock;
256             if (runLock.tryLock()) {
257                 try {
258             if (thread != Thread.currentThread())
259             thread.interrupt();
260                 } finally {
261                     runLock.unlock();
262                 }
263             }
264         }
265         // 中断
266         void interruptNow() {
267             thread.interrupt();
268         }
269 
270         
271         private void runTask(Runnable task) {
272             final ReentrantLock runLock = this.runLock;
273             runLock.lock();
274             try {
275                 
276                 if (runState < STOP &&
277                     Thread.interrupted() &&
278                     runState >= STOP)
279                     thread.interrupt();
280                 
281                 boolean ran = false;
282                 beforeExecute(thread, task);
283                 try {
284                     task.run();
285                     ran = true;
286                     afterExecute(task, null);
287                     ++completedTasks;
288                 } catch (RuntimeException ex) {
289                     if (!ran)
290                         afterExecute(task, ex);
291                     throw ex;
292                 }
293             } finally {
294                 runLock.unlock();
295             }
296         }
297 
298         
299         public void run() {
300             try {
301                 Runnable task = firstTask;
302                 firstTask = null;
303                 /** 
304                  * 注意这段while循环的执行逻辑,每执行完一个核心线程后,就会去线程池 
305                  * 队列中取下一个核心线程,如取出的核心线程为null,则当前工作线程终止 
306                  */  
307                 while (task != null || (task = getTask()) != null) {
308                     //你所提交的核心线程(任务)的运行逻辑  
309                     runTask(task);
310                     task = null;
311                 }
312             } finally {
313                 // 当前工作线程退出  
314                 workerDone(this);
315             }
316         }
317     }
318 
319     // 从池队列中取的核心线程(任务)的方法
320     Runnable getTask() {
321         for (;;) {
322             try {
323                 // 获取运行状态
324                 int state = runState;
325                 // 大于SHUTDOWN,即STOP和TERMINATED状态,没有任务
326                 if (state > SHUTDOWN)
327                     return null;
328                 Runnable r;
329                 // SHUTDOWN状态
330                 if (state == SHUTDOWN)  // 帮助清空队列
331                     r = workQueue.poll();
332                 // 状态时RUNNING,且poolSize > corePoolSize或allowCoreThreadTimeOut
333                 else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
334                     // 获取并移除元素(等待指定的时间)
335                     r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
336                 else
337                     // 获取并移除元素(会一直等待知道获取到有效元素)
338                     r = workQueue.take();
339                 // 获取结果不为空,返回
340                 if (r != null)
341                     return r;
342                 // 检查一个获取任务失败的线程能否退出
343                 if (workerCanExit()) {
344                     if (runState >= SHUTDOWN) // 中断其他线程
345                         interruptIdleWorkers();
346                     return null;
347                 }
348                 // Else retry
349             } catch (InterruptedException ie) {
350                 // On interruption, re-check runState
351             }
352         }
353     }
354 
355     // 检查一个获取任务失败的线程能否退出
356     private boolean workerCanExit() {
357         final ReentrantLock mainLock = this.mainLock;
358         mainLock.lock();
359         boolean canExit;
360         try {
361             // 可以退出的条件是状态为STOP或TERMINATED或至少有一个处理非空队列的线程(在允许超时的情况下)
362             canExit = runState >= STOP ||
363                 workQueue.isEmpty() ||
364                 (allowCoreThreadTimeOut &&
365                  poolSize > Math.max(1, corePoolSize));
366         } finally {
367             mainLock.unlock();
368         }
369         return canExit;
370     }
371 
372     // 中断其他线程
373     void interruptIdleWorkers() {
374         final ReentrantLock mainLock = this.mainLock;
375         mainLock.lock();
376         try {
377             // 遍历工作线程
378             for (Worker w : workers)
379                 // 尝试中断闲置线程
380                 w.interruptIfIdle();
381         } finally {
382             mainLock.unlock();
383         }
384     }
385     // 工作线程退出要处理的逻辑 
386     void workerDone(Worker w) {
387         final ReentrantLock mainLock = this.mainLock;
388         mainLock.lock();
389         try {
390             completedTaskCount += w.completedTasks;
391             workers.remove(w);//从工作线程缓存中删除  
392             if (--poolSize == 0)//poolSize减一,这时其实又可以创建工作线程了  
393                 tryTerminate();//尝试终止  
394         } finally {
395             mainLock.unlock();
396         }
397     }
398 
399     // 尝试终止
400     private void tryTerminate() {
401         //终止的前提条件就是线程池里已经没有工作线程(Worker)了  
402         if (poolSize == 0) {
403             int state = runState;
404             /** 
405              * 如果当前已经没有了工作线程(Worker),但是线程队列里还有等待的线程任务,则创建一个 
406              * 工作线程来执行线程队列中等待的任务 
407              */  
408             if (state < STOP && !workQueue.isEmpty()) {
409                 state = RUNNING; // disable termination check below
410                 Thread t = addThread(null);
411                 if (t != null)
412                     t.start();
413             }
414             // 设置池状态为终止状态  
415             if (state == STOP || state == SHUTDOWN) {
416                 runState = TERMINATED;
417                 termination.signalAll();
418                 terminated();
419             }
420         }
421     }
422     // 发起一个有序的关闭在以前已提交任务的执行,但不接受新任务。如果已经关闭,调用不会有其他影响。
423     public void shutdown() {
424         // Gets the system security interface.
425         SecurityManager security = System.getSecurityManager();
426         if (security != null)
427             // 检查权限(以抛出异常的形式)
428             security.checkPermission(shutdownPerm);
429         final ReentrantLock mainLock = this.mainLock;
430         mainLock.lock();
431         try {
432             if (security != null) { // 检查调用者是否能修改线程
433                 for (Worker w : workers)
434                     security.checkAccess(w.thread);
435             }
436             // 获取运行状态
437             int state = runState;
438             // 小于SHUTDOWN的不就是RUNNING么。。。
439             if (state < SHUTDOWN)
440                 runState = SHUTDOWN;
441 
442             try {
443                 for (Worker w : workers) {
444                     // 中断线程
445                     w.interruptIfIdle();
446                 }
447             } catch (SecurityException se) { // Try to back out
448                 runState = state;
449                 // tryTerminate() here would be a no-op
450                 throw se;
451             }
452             // 尝试终止
453             tryTerminate(); // Terminate now if pool and queue empty
454         } finally {
455             mainLock.unlock();
456         }
457     }
458 
459     
460     public List<Runnable> shutdownNow() {
461         SecurityManager security = System.getSecurityManager();
462         if (security != null)
463             security.checkPermission(shutdownPerm);
464 
465         final ReentrantLock mainLock = this.mainLock;
466         mainLock.lock();
467         try {
468             if (security != null) { // Check if caller can modify our threads
469                 for (Worker w : workers)
470                     security.checkAccess(w.thread);
471             }
472 
473             int state = runState;
474             // 与上一个方法主要区别在于状态和interruptNow方法
475             if (state < STOP)
476                 runState = STOP;
477 
478             try {
479                 for (Worker w : workers) {
480                     w.interruptNow();
481                 }
482             } catch (SecurityException se) { // Try to back out
483                 runState = state;
484                 // tryTerminate() here would be a no-op
485                 throw se;
486             }
487 
488             List<Runnable> tasks = drainQueue();
489             tryTerminate(); // Terminate now if pool and queue empty
490             return tasks;
491         } finally {
492             mainLock.unlock();
493         }
494     }
495 
496     // 清空队列
497     private List<Runnable> drainQueue() {
498         List<Runnable> taskList = new ArrayList<Runnable>();
499         // 将队列中的所有元素一到taskList中
500         workQueue.drainTo(taskList);
501         while (!workQueue.isEmpty()) {
502             Iterator<Runnable> it = workQueue.iterator();
503             try {
504                 if (it.hasNext()) {
505                     Runnable r = it.next();
506                     // 从workQueue中移除,并添加到taskList中
507                     if (workQueue.remove(r))
508                         taskList.add(r);
509                 }
510             } catch (ConcurrentModificationException ignore) {
511             }
512         }
513         return taskList;
514     }
515 
516     public boolean isShutdown() {
517         return runState != RUNNING;
518     }
519 
520     
521     boolean isStopped() {
522         return runState == STOP;
523     }
524 
525     
526     public boolean isTerminating() {
527         int state = runState;
528         return state == SHUTDOWN || state == STOP;
529     }
530 
531     public boolean isTerminated() {
532         return runState == TERMINATED;
533     }
534     
535     public boolean awaitTermination(long timeout, TimeUnit unit)
536         throws InterruptedException {
537         long nanos = unit.toNanos(timeout);
538         final ReentrantLock mainLock = this.mainLock;
539         mainLock.lock();
540         try {
541             for (;;) {
542                 if (runState == TERMINATED)
543                     return true;
544                 if (nanos <= 0)
545                     return false;
546                 nanos = termination.awaitNanos(nanos);
547             }
548         } finally {
549             mainLock.unlock();
550         }
551     }
552 
553     
554     protected void finalize()  {
555         shutdown();
556     }
557 
558     
559     public void setThreadFactory(ThreadFactory threadFactory) {
560         if (threadFactory == null)
561             throw new NullPointerException();
562         this.threadFactory = threadFactory;
563     }
564 
565     
566     public ThreadFactory getThreadFactory() {
567         return threadFactory;
568     }
569 
570     
571     public void setRejectedExecutionHandler(RejectedExecutionHandler handler) {
572         if (handler == null)
573             throw new NullPointerException();
574         this.handler = handler;
575     }
576 
577     
578     public RejectedExecutionHandler getRejectedExecutionHandler() {
579         return handler;
580     }
581 
582     // 设置核心线程数 这里的设置将覆盖构造方法中的设置
583     // 如果小于构造方法的设置,多余的线程将被闲置
584     // 如果大于构造方法的设置,新线程将被用于执行排队的任务
585     public void setCorePoolSize(int corePoolSize) {
586         if (corePoolSize < 0)
587             throw new IllegalArgumentException();
588         final ReentrantLock mainLock = this.mainLock;
589         mainLock.lock();
590         try {
591             int extra = this.corePoolSize - corePoolSize;
592             this.corePoolSize = corePoolSize;
593             // 大于构造方法的设置
594             if (extra < 0) {
595                 int n = workQueue.size(); 
596                 while (extra++ < 0 && n-- > 0 && poolSize < corePoolSize) {
597                     Thread t = addThread(null);
598                     if (t != null)
599                         t.start();
600                     else
601                         break;
602                 }
603             }
604             // 小于构造方法的设置
605             else if (extra > 0 && poolSize > corePoolSize) {
606                 try {
607                     Iterator<Worker> it = workers.iterator();
608                     while (it.hasNext() &&
609                            extra-- > 0 &&
610                            poolSize > corePoolSize &&
611                            workQueue.remainingCapacity() == 0)
612                         it.next().interruptIfIdle();
613                 } catch (SecurityException ignore) {
614                     // Not an error; it is OK if the threads stay live
615                 }
616             }
617         } finally {
618             mainLock.unlock();
619         }
620     }
621 
622     
623     public int getCorePoolSize() {
624         return corePoolSize;
625     }
626 
627     
628     public boolean prestartCoreThread() {
629         return addIfUnderCorePoolSize(null);
630     }
631 
632     
633     public int prestartAllCoreThreads() {
634         int n = 0;
635         while (addIfUnderCorePoolSize(null))
636             ++n;
637         return n;
638     }
639 
640     
641     public boolean allowsCoreThreadTimeOut() {
642         return allowCoreThreadTimeOut;
643     }
644 
645     
646     public void allowCoreThreadTimeOut(boolean value) {
647         if (value && keepAliveTime <= 0)
648             throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
649 
650         allowCoreThreadTimeOut = value;
651     }
652 
653     // 设置所允许的最大的线程数。这将覆盖在构造函数中设置的任何值。如果新值小于当前值,多余的现有线程将被终止时,他们成为闲置。
654     public void setMaximumPoolSize(int maximumPoolSize) {
655         if (maximumPoolSize <= 0 || maximumPoolSize < corePoolSize)
656             throw new IllegalArgumentException();
657         final ReentrantLock mainLock = this.mainLock;
658         mainLock.lock();
659         try {
660             int extra = this.maximumPoolSize - maximumPoolSize;
661             this.maximumPoolSize = maximumPoolSize;
662             if (extra > 0 && poolSize > maximumPoolSize) {
663                 try {
664                     Iterator<Worker> it = workers.iterator();
665                     while (it.hasNext() &&
666                            extra > 0 &&
667                            poolSize > maximumPoolSize) {
668                         it.next().interruptIfIdle();
669                         --extra;
670                     }
671                 } catch (SecurityException ignore) {
672                     // Not an error; it is OK if the threads stay live
673                 }
674             }
675         } finally {
676             mainLock.unlock();
677         }
678     }
679 
680     
681     public int getMaximumPoolSize() {
682         return maximumPoolSize;
683     }
684 
685     
686     public void setKeepAliveTime(long time, TimeUnit unit) {
687         if (time < 0)
688             throw new IllegalArgumentException();
689         if (time == 0 && allowsCoreThreadTimeOut())
690             throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
691         this.keepAliveTime = unit.toNanos(time);
692     }
693 
694     
695     public long getKeepAliveTime(TimeUnit unit) {
696         return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
697     }
698 
699     
700     public BlockingQueue<Runnable> getQueue() {
701         return workQueue;
702     }
703 
704     
705     public boolean remove(Runnable task) {
706         return getQueue().remove(task);
707     }
708 
709     // 移除所有被取消的任务
710     public void purge() {
711         // Fail if we encounter interference during traversal
712         try {
713             Iterator<Runnable> it = getQueue().iterator();
714             while (it.hasNext()) {
715                 Runnable r = it.next();
716                 if (r instanceof Future<?>) {
717                     Future<?> c = (Future<?>)r;
718                     if (c.isCancelled())
719                         it.remove();
720                 }
721             }
722         }
723         catch (ConcurrentModificationException ex) {
724             return;
725         }
726     }
727 
728     
729     public int getPoolSize() {
730         return poolSize;
731     }
732 
733     // 获取活跃线程数
734     public int getActiveCount() {
735         final ReentrantLock mainLock = this.mainLock;
736         mainLock.lock();
737         try {
738             int n = 0;
739             for (Worker w : workers) {
740                 if (w.isActive())
741                     ++n;
742             }
743             return n;
744         } finally {
745             mainLock.unlock();
746         }
747     }
748 
749     
750     public int getLargestPoolSize() {
751         final ReentrantLock mainLock = this.mainLock;
752         mainLock.lock();
753         try {
754             return largestPoolSize;
755         } finally {
756             mainLock.unlock();
757         }
758     }
759 
760     
761     public long getTaskCount() {
762         final ReentrantLock mainLock = this.mainLock;
763         mainLock.lock();
764         try {
765             long n = completedTaskCount;
766             for (Worker w : workers) {
767                 // 统计已经完成的任务
768                 n += w.completedTasks;
769                 // 如果w是活跃线程,说明正在执行一个任务,所以n加一
770                 if (w.isActive())
771                     ++n;
772             }
773             // 加上队列中的任务
774             return n + workQueue.size();
775         } finally {
776             mainLock.unlock();
777         }
778     }
779 
780     // 获取已完成的任务数
781     public long getCompletedTaskCount() {
782         final ReentrantLock mainLock = this.mainLock;
783         mainLock.lock();
784         try {
785             long n = completedTaskCount;
786             for (Worker w : workers)
787                 n += w.completedTasks;
788             return n;
789         } finally {
790             mainLock.unlock();
791         }
792     }
793 
794     
795     protected void beforeExecute(Thread t, Runnable r) { }
796 
797     
798     protected void afterExecute(Runnable r, Throwable t) { }
799 
800     
801     protected void terminated() { }
802 
803     // 实现了RejectedExecutionHandler,即是一个拒绝执行的Handler
804     public static class CallerRunsPolicy implements RejectedExecutionHandler {
805         
806         public CallerRunsPolicy() { }
807 
808     
809         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
810             if (!e.isShutdown()) {
811                 r.run();
812             }
813         }
814     }
815 
816     
817     public static class AbortPolicy implements RejectedExecutionHandler {
818         
819         public AbortPolicy() { }
820 
821         
822         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
823             throw new RejectedExecutionException();
824         }
825     }
826 
827     
828     public static class DiscardPolicy implements RejectedExecutionHandler {
829         
830         public DiscardPolicy() { }
831 
832         
833         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
834         }
835     }
836 
837     
838     public static class DiscardOldestPolicy implements RejectedExecutionHandler {
839         
840         public DiscardOldestPolicy() { }
841 
842         
843         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
844             if (!e.isShutdown()) {
845                 e.getQueue().poll();
846                 e.execute(r);
847             }
848         }
849     }
850 }

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

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

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

    ScheduledThreadPoolExecutor

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中所定义的 ExecutorExecutorServiceScheduledExecutorServiceThreadFactoryCallable 类的工厂和实用方法。此类支持以下各种方法:

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

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

   RunnableAdapter

 1 static final class RunnableAdapter<T> implements Callable<T> {
 2         final Runnable task;
 3         final T result;
 4         RunnableAdapter(Runnable  task, T result) {
 5             this.task = task;
 6             this.result = result;
 7         }
 8         public T call() {
 9             task.run();
10             return result;
11         }
12 }

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

    PrivilegedCallable

 1 static final class PrivilegedCallable<T> implements Callable<T> {
 2     private final AccessControlContext acc;
 3     private final Callable<T> task;
 4     private T result;
 5     private Exception exception;
 6     PrivilegedCallable(Callable<T> task) {
 7         this.task = task;
 8         this.acc = AccessController.getContext();
 9     }
10 
11     public T call() throws Exception {
12         AccessController.doPrivileged(new PrivilegedAction<T>() {
13             public T run() {
14                 try {
15                     result = task.call();
16                 } catch (Exception ex) {
17                     exception = ex;
18                 }
19                 return null;
20             }
21         }, acc);
22         if (exception != null)
23             throw exception;
24         else
25             return result;
26     }
27 }

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

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

    DefaultThreadFactory

 1     static class DefaultThreadFactory implements ThreadFactory {
 2         static final AtomicInteger poolNumber = new AtomicInteger(1);
 3         final ThreadGroup group;
 4         final AtomicInteger threadNumber = new AtomicInteger(1);
 5         final String namePrefix;
 6 
 7         DefaultThreadFactory() {
 8             SecurityManager s = System.getSecurityManager();
 9             group = (s != null)? s.getThreadGroup() :
10                                  Thread.currentThread().getThreadGroup();
11             namePrefix = "pool-" +
12                           poolNumber.getAndIncrement() +
13                          "-thread-";
14         }
15 
16         public Thread newThread(Runnable r) {
17             // 调用Thread构造方法创建线程
18             Thread t = new Thread(group, r,
19                                   namePrefix + threadNumber.getAndIncrement(),
20                                   0);
21             // 取消守护线程设置
22             if (t.isDaemon())
23                 t.setDaemon(false);
24             // 设置默认优先级
25             if (t.getPriority() != Thread.NORM_PRIORITY)
26                 t.setPriority(Thread.NORM_PRIORITY);
27             return t;
28         }
29     }

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

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

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

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

 

如果本文对您有帮助,点一下右下角的“推荐”

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Spring Boot Admin,贼好使!(8)
Spring Boot Admin,贼好使!(8)
22 0
Spring Boot Admin,贼好使!(7)
Spring Boot Admin,贼好使!(7)
23 0
更快的Maven构建工具mvnd和Gradle哪个性能更好?(5)
更快的Maven构建工具mvnd和Gradle哪个性能更好?(5)
22 0
Spring Boot Admin,贼好使!(5)
Spring Boot Admin,贼好使!(5)
33 0
保姆级教程,终于搞懂脏读、幻读和不可重复读了!(6)
保姆级教程,终于搞懂脏读、幻读和不可重复读了!(6)
25 0
保姆级教程,终于搞懂脏读、幻读和不可重复读了!(7)
保姆级教程,终于搞懂脏读、幻读和不可重复读了!(7)
22 0
更快的Maven构建工具mvnd和Gradle哪个性能更好?(4)
更快的Maven构建工具mvnd和Gradle哪个性能更好?(4)
19 0
更快的Maven构建工具mvnd和Gradle哪个性能更好?(3)
更快的Maven构建工具mvnd和Gradle哪个性能更好?(3)
31 0
Spring Boot Admin,贼好使!(3)
Spring Boot Admin,贼好使!(3)
27 0
Spring Boot Admin,贼好使!(4)
Spring Boot Admin,贼好使!(4)
27 0
+关注
蘑菇街隐修
专注分布式消息中间件和存储系统
69
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载