ScheduledThreadPoolExecutor

自jdk1.5开始，Java开始提供ScheduledThreadPoolExecutor类来支持周期性任务的调度，在这之前，这些工作需要依靠Timer/TimerTask或者其它第三方工具来完成。但Timer有着不少缺陷，如Timer是单线程模式，调度多个周期性任务时，如果某个任务耗时较久就会影响其它任务的调度；如果某个任务出现异常而没有被catch则可能导致唯一的线程死掉而所有任务都不会再被调度。ScheduledThreadPoolExecutor解决了很多Timer存在的缺陷。

先来看看ScheduledThreadPoolExecutor的实现模型，它通过继承ThreadPoolExecutor来重用线程池的功能，里面做了几件事情：

• 为线程池设置了一个DelayedWorkQueue，该queue同时具有PriorityQueue（优先级大的元素会放到队首）和DelayQueue（如果队列里第一个元素的getDelay返回值大于0，则take调用会阻塞）的功能
• 将传入的任务封装成ScheduledFutureTask，这个类有两个特点，实现了java.lang.Comparable和java.util.concurrent.Delayed接口，也就是说里面有两个重要的方法：compareTo和getDelay。ScheduledFutureTask里面存储了该任务距离下次调度还需要的时间（使用的是基于System#nanoTime实现的相对时间，不会因为系统时间改变而改变，如距离下次执行还有10秒，不会因为将系统时间调前6秒而变成4秒后执行）。getDelay方法就是返回当前时间（运行getDelay的这个时刻）距离下次调用之间的时间差；compareTo用于比较两个任务的优先关系，距离下次调度间隔较短的优先级高。那么，当有任务丢进上面说到的DelayedWorkQueue时，因为它有DelayQueue（DelayQueue的内部使用PriorityQueue来实现的）的功能，所以新的任务会与队列中已经存在的任务进行排序，距离下次调度间隔短的任务排在前面，也就是说这个队列并不是先进先出的；另外，在调用DelayedWorkQueue的take方法的时候，如果没有元素，会阻塞，如果有元素而第一个元素的getDelay返回值大于0（前面说过已经排好序了，第一个元素的getDelay不会大于后面元素的getDelay返回值），也会一直阻塞。
• ScheduledFutureTask提供了一个run的实现，线程池执行的就是这个run方法。看看run的源码（本文的代码取自hotspot1.5.0_22，jdk后续版本的代码可能已经不一样了，如jdk1.7中使用了自己实现的DelayedWorkQueue，而不再使用PriorityQueue作为存储，不过从外面看它们的行为还是一样的，所以并不影响对ScheduledThreadPoolExecutor调度机制的理解）：

  public void run() {      if (isPeriodic())          runPeriodic();      else          ScheduledFutureTask. super .run(); }

  如果不是周期性任务就直接执行任务（也就是else部分），这个主要是用于实现ScheduledThreadPoolExecutor#schedule(Callable callable, long delay, TimeUnit unit)和ScheduledThreadPoolExecutor#schedule(Runnable command, long delay, TimeUnit unit)，后面会讲到它们的实现，这里先关注周期任务的执行方式。周期性任务执行的是runPeriodic(),看下它的实现：

  private void runPeriodic() {      boolean ok = ScheduledFutureTask. super .runAndReset();      boolean down = isShutdown();      // Reschedule if not cancelled and not shutdown or policy allows      if (ok && (!down ||                 (getContinueExistingPeriodicTasksAfterShutdownPolicy() &&                  !isTerminating()))) {          long p = period;          if (p > 0 )              time += p;          else              time = triggerTime(-p);          ScheduledThreadPoolExecutor. super .getQueue().add( this );      }      // This might have been the final executed delayed      // task.  Wake up threads to check.      else if (down)          interruptIdleWorkers(); }

  这里可以看到，先执行了任务本身（ScheduledFutureTask.super.runAndReset），这个调用有一个返回值，来看下它的实现：

  protected boolean runAndReset() {      return sync.innerRunAndReset(); }

  跟进去看下innerRunAndReset():

  boolean innerRunAndReset() {      if (!compareAndSetState( 0 , RUNNING))          return false ;      try {          runner = Thread.currentThread();          callable.call(); // don't set result          runner = null ;          return compareAndSetState(RUNNING, 0 );      } catch (Throwable ex) {          innerSetException(ex);          return false ;      } }

  可以发现，这里需要关注的是第三个return，也就是如果任务执行出现了异常，会被catch且返回false.

  继续看runPeriodic()方法，if里面，如果刚才任务执行的返回值是true且线程池还在运行就在if块中的操作，如果线程池被关闭了就做else if里的操作。也就是说，如果之前的任务执行出现的异常返回了false，那么if里以及else if里的代码都不会执行了，那有什么影响？接下来看看if里做了什么。

  if里的代码很简单，分为两部分，一是计算这个任务下次调度的间隔，二是将任务重新放回队列中。回到出现异常的情况，如果刚才的任务执行出现了异常，就不会将任务再放回队列中，换而言之，也就是这个任务再也得不到调度了！但是，这并不影响其它周期任务的调度。

综上，可以看到，ScheduledThreadPoolExecutor执行周期性任务的模型就是：调度一次任务，计算并设置该任务下次间隔，将任务放回队列中供线程池执行。这里的队列起了很大的作用，且有一些特点：距离下次调度间隔短的任务总是在队首，队首的任务若距离下次调度的间隔时间大于0就无法从该队列的take()方法中拿到任务。

接下来看看ScheduledThreadPoolExecutor#schedule(Callable callable, long delay, TimeUnit unit)和ScheduledThreadPoolExecutor#schedule(Runnable command, long delay, TimeUnit unit)这两个非周期性任务的实现方式，先看看它们的源码：

public ScheduledFuture<?> schedule(Runnable command,                                     long delay,                                     TimeUnit unit) {      if (command == null || unit == null )          throw new NullPointerException();      ScheduledFutureTask<?> t =          new ScheduledFutureTask<Boolean>(command, null , triggerTime(delay, unit));      delayedExecute(t);      return t; }

public <V> ScheduledFuture<V> schedule(Callable<V> callable,                                         long delay,                                         TimeUnit unit) {      if (callable == null || unit == null )          throw new NullPointerException();      ScheduledFutureTask<V> t =          new ScheduledFutureTask<V>(callable, triggerTime(delay, unit));      delayedExecute(t);      return t; }

private void delayedExecute(Runnable command) {      if (isShutdown()) {          reject(command);          return ;      }      // Prestart a thread if necessary. We cannot prestart it      // running the task because the task (probably) shouldn't be      // run yet, so thread will just idle until delay elapses.      if (getPoolSize() < getCorePoolSize())          prestartCoreThread();                super .getQueue().add(command); }

实现方式也很简单，在创建ScheduledThreadPoolExecutor内部任务（即ScheduledFutureTask）的时候就将调度间隔计算并设置好，如果当前线程数小于设置的核心线程数，就启动一个线程（可能是线程池刚启动里面还没有线程，也可能是里面的线程执行任务时挂掉了。如果线程池中的线程挂掉了而又没有调用这些schedule方法谁去补充挂掉的线程？不用担心，线程池自己会处理的）去监听队列里的任务，然后将任务放到队列里，在任务执行间隔不大于0的时候，线程就可以拿到这个任务并执行。

周期性任务的入口（ScheduledThreadPoolExecutor#scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)和ScheduledThreadPoolExecutor#scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)）与非周期性任务是类似的，它们处理方式不同的地方在于前文说到的ScheduledFutureTask#run()中。

package concurrentTest;

import java.util.concurrent.*;

/**
 * Created by mashao on 15/9/22.
 */
public class TestSceduleThreadPool {

    static long time = 0L;
    public static void main(String[] args) {
        ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1);

        executor.schedule(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                time = System.currentTimeMillis();
                System.out.println("thread 1");
            }
        }, 1000, TimeUnit.MILLISECONDS);
        executor.schedule(new Runnable() {
            public void run() {
                System.out.println(System.currentTimeMillis() - time);
                System.out.println("thread 2");
            }
        }, 3000, TimeUnit.MILLISECONDS);
        executor.shutdown();
    }
}