聊聊高并发（四十三）解析java.util.concurrent各个组件（十九） 任务的定时执行和周期执行

ExecutorService最后一块是定时/周期执行任务的接口ScheduledExecutorService。这篇说说ScheduledExecutorService相关的内容。

ScheduledExecutorService接口扩展了ExecutorService接口，在ExecutorService的生命周期管理，异步执行任务，批量执行任务的基础上，扩展了定时/周期执行任务的能力。

1. schedule方法提供了Runnable和Callable的两种任务的输入，可以设置延迟时间来执行任务，是一次性的

2. scheduleAtFixedRate方法提供了固定周期执行任务的能力，只支持Runnable任务。需要注意的是一旦某次执行任务抛出异常，后续的任务将会停止执行。任务的执行时间是initialDelay，initialDelay+period， initialDelay + 2 * period，不管前一个任务是否执行完成。

3. scheduleWithFixedDelay方法提供了固定延迟时间执行任务的能力，只支持Runnable任务。后一天任务在前一个任务执行完成后，再延迟delay时间再执行。

public interface ScheduledExecutorService extends ExecutorService {

    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);

    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

}

ScheduledExecutorService的方法返回的类型都是ScheduledFuture。ScheduleFuture接口定义如下。它扩展了Future接口和Delayed接口。和RunnableFuture不同，RunnableFuture扩展了Future和Runnable接口

public interface ScheduledFuture<V> extends Delayed, Future<V> {
}

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

 

而为了把ScheduledFuture接口和Runnable接口适配，又定义了RunnableScheduledFuture接口扩展了RunnableFuture和ScheduleFuture，这样RunnableScheduledFuture就可以被Executor框架执行，又具备了Future异步状态控制和Scheduled定时周期执行的能力。

public interface RunnableScheduledFuture<V> extends RunnableFuture<V>, ScheduledFuture<V> {

    boolean isPeriodic();
}

ScheduledFutureTask类实现了RunnableScheduledFuture接口。它同时继承了FutureTask来获得RunnableFuture的能力，只需要再实现定时/周期执行相关的能力即可。

ScheduledFutureTask的主要属性如下

1. private final long sequenceNumber;    序列号
2. private long time;   任务开始执行的时间
3. private final long period;   周期执行任务的时间周期。大于0表示周期执行fixed-rate，等于0表示只执行一次，小于0表示周期延迟执行fixed-delay
4. RunnableScheduledFuture<V> outerTask = this;   当前ScheduledFutureTask对象的引用，为了reExecute重新执行时可以找到对象
5. int heapIndex;    延迟队列的索引号

ScheduledFutureTask的构造函数如下

第一个构造函数支持Runnable接口，表示只执行一次

第二个构造函数支持Callable接口，表示只执行一次

第三个构造函数传入period，period大于0表示fixed-rate，0表示执行一次，小于0表示fixed-delay

ns表示开始执行任务的时间，用纳秒表示

        ScheduledFutureTask(Runnable r, V result, long ns) {
            super(r, result);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

        ScheduledFutureTask(Callable<V> callable, long ns) {
            super(callable);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }

ScheduledFutureTask(Runnable r, V result, long ns, long period) { super(r, result); this.time = ns; this.period = period; this.sequenceNumber = sequencer.getAndIncrement(); }

几个重要的方法，首先是和时间相关的方法

1. setNextRunTime()计算下次执行任务的时间。可以看到，当period大于0时表示fixed-rate的方式周期执行，每次执行的时间是固定的，从第一次开始执行，然后每次加上period，一旦开始运行就可以计算出每次执行的时间。

当period小于0时，表示fixed-delay方式周期执行，每次是取当前时间 + delay，当前时间是前一个任务执行完成的时间。受到当前任务执行时间的影响

2. comparedTo是Delayd接口要实现的方法，计算两个ScheduledFutureTask直接的时间间隔

 private void setNextRunTime() {
            long p = period;
            if (p > 0)
                time += p;
            else
                time = triggerTime(-p);
        }

  long triggerTime(long delay) {
        return now() +
            ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
    }

public int compareTo(Delayed other) {
            if (other == this) // compare zero ONLY if same object
                return 0;
            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);
        }

run方法是SchduledFutuerTask实现了Runnable接口，用来被Executor框架执行用的。

先判断是否是周期执行，如果Executor当前状态不能执行，就cancel，否则如果不是周期执行，就直接使用父类FutureTask的run方法即可。

如果是周期性执行任务，那么调用FutureTask的runAndReset方法，执行任务，然后重置ExecutorService状态。如果执行成功，就获取下次执行的时间，再调用reExecutePeriodic把任务加入工作队列

 public void run() {
            boolean periodic = isPeriodic();
            if (!canRunInCurrentRunState(periodic))
                cancel(false);
            else if (!periodic)
                ScheduledFutureTask.super.run();
            else if (ScheduledFutureTask.super.runAndReset()) {
                setNextRunTime();
                reExecutePeriodic(outerTask);
            }
        }

void reExecutePeriodic(RunnableScheduledFuture<?> task) {
        if (canRunInCurrentRunState(true)) {
            super.getQueue().add(task);
            if (!canRunInCurrentRunState(true) && remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

ExecutorService是工作线程Worker，工作队列BlockingQueue，和任务RunnableFuture的三元组，<Worker, BlockingQueue, RunnaleFuture>。说完了ScheduledFutureTask，来看下定时/周期执行任务相关的工作队列DelayedWorkQueue

DelayedWorkQueue的目的是将工作队列组织成按照delay时间排序的队列，它存放的任务是RunnableScheduledFuture接口类型，实际实现的时候，对ScheduledFutureTask类型做了优化，ScheduledFutureTask维护了一个heapIndex，在取消任务时，需要将ScheduledFutureTask移出工作队列，heapIndex降低了查找的时间复杂度。

DelayedWorkQueue需要注意的是2点

1. 出入队列时，根据Delayed接口进行排序，delay越小越靠近队首，越早出队列

2. 采用了Leader/Follower模式优化了多线程取任务的模型，减少了多线程的竞争

siftUp和siftDown方法会根据ScheduledFutureTask的dealy时间调整它在工作队列中的位置，注意提升和下降时，没有和相邻的节点比较，而是按照2的倍数的位置来比较

       private void siftUp(int k, RunnableScheduledFuture key) {
            while (k > 0) {
                int parent = (k - 1) >>> 1;
                RunnableScheduledFuture e = queue[parent];
                if (key.compareTo(e) >= 0)
                    break;
                queue[k] = e;
                setIndex(e, k);
                k = parent;
            }
            queue[k] = key;
            setIndex(key, k);
        }

        private void siftDown(int k, RunnableScheduledFuture key) {
            int half = size >>> 1;
            while (k < half) {
                int child = (k << 1) + 1;
                RunnableScheduledFuture c = queue[child];
                int right = child + 1;
                if (right < size && c.compareTo(queue[right]) > 0)
                    c = queue[child = right];
                if (key.compareTo(c) <= 0)
                    break;
                queue[k] = c;
                setIndex(c, k);
                k = child;
            }
            queue[k] = key;
            setIndex(key, k);
        }

入队列操作由offer方法实现, Condition available = lock.newCondition() 是全局锁的条件，当take/poll取元素时，如果队列为空，那么相应的线程就阻塞，在available的条件队列上等待。

offer入队列的逻辑很清晰

1. 首先判断队列长度是否足够，不够就扩容。

2. 如果进入空队列，那么入队任务就是队首。

3. 如果入的不是空队列，就按照入队任务的dealy时间调整它在队列中的位置

4. 如果入队任务成为队首，那么就按照Leader/Follower模式，唤醒一个在available条件队列上等待的Follower线程去做新的leader。

 public boolean offer(Runnable x) {
            if (x == null)
                throw new NullPointerException();
            RunnableScheduledFuture e = (RunnableScheduledFuture)x;
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                int i = size;
                if (i >= queue.length)
                    grow();
                size = i + 1;
                if (i == 0) {
                    queue[0] = e;
                    setIndex(e, 0);
                } else {
                    siftUp(i, e);
                }
                if (queue[0] == e) {
                    leader = null;
                    available.signal();
                }
            } finally {
                lock.unlock();
            }
            return true;
        }

阻塞队列的出队列操作take实现如下，可以看到Leader/Follower模式是如何工作的

1. 先要获取全局锁，take是串行操作。当队列空时，线程在available条件队列上阻塞等待

2. 如果队列不为空，先计算任务的delay时间，如果delay <=0了，表示任务可以被执行了，就finishPoll，返回队首任务

3. 如果delay >0 表示队首任务还要等待一段时间，如果leader !=null，表示已经有leader在等待了，其他线程都是follwer，在available条件队列等待

4. 如果leader == null，表示这个当前线程可以成为leader，把当前线程设置为leader，然后限时等待delay时间。等待结束后，如果当前线程是是leader，就把leader设置为空，可以让从follower中唤醒一个成为leader。当前线程再次循环，此时dealy<0，可以返回了

5. 注意最外层的finally是在return finishPoll之前执行的，看看如何从follower中唤醒一个来作leader的： if(leader==null && queue[0] != null){available.signal()}

总结一下Leader/Follower模式，该模式可以减少多线程在取任务时的竞争。leader总是只有一个，follower线程在条件队列等待。等Leader获取到任务后，它先唤醒一个follower成为新的leader，然后再去执行任务。

 public RunnableScheduledFuture take() throws InterruptedException {
            final ReentrantLock lock = this.lock;
            lock.lockInterruptibly();
            try {
                for (;;) {
                    RunnableScheduledFuture first = queue[0];
                    if (first == null)
                        available.await();
                    else {
                        long delay = first.getDelay(TimeUnit.NANOSECONDS);
                        if (delay <= 0)
                            return finishPoll(first);
                        else if (leader != null)
                            available.await();
                        else {
                            Thread thisThread = Thread.currentThread();
                            leader = thisThread;
                            try {
                                available.awaitNanos(delay);
                            } finally {
                                if (leader == thisThread)
                                    leader = null;
                            }
                        }
                    }
                }
            } finally {
                if (leader == null && queue[0] != null)
                    available.signal();
                lock.unlock();
            }
        }

最后再来看看ScheduledExecutorService的实现类ScheduledThreadPoolExecutor。

构造函数默认使用了DelayedWorkQueue作为工作队列

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

execute, submit方法都委托给了schedule方法，schedule方法是一次性的

 public void execute(Runnable command) {
        schedule(command, 0, TimeUnit.NANOSECONDS);
    }

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

schedule方法把Runnable, Callable等不同接口的参数统一使用了RunnableScheduledFuture进行封装，然后委托给delayedExecute方法执行。

创建ScheduleFutureTask时，使用了triggerTime计算出了这个任务应该被触发的时间

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

 long triggerTime(long delay) {
        return now() +
            ((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
    }

delayedExecute方法也很简单，只是根据ExecutorService状态，把任务加入到工作队列。具体判断任务是否可以执行（dely时间到期）的逻辑在DelayedWorkQueue的take方法里实现。

   private void delayedExecute(RunnableScheduledFuture<?> task) {
        if (isShutdown())
            reject(task);
        else {
            super.getQueue().add(task);
            if (isShutdown() &&
                !canRunInCurrentRunState(task.isPeriodic()) &&
                remove(task))
                task.cancel(false);
            else
                ensurePrestart();
        }
    }

周期执行的两个方法scheduleAtFixedRate和scheduleAtFixedDealy方法基本一致，唯一不同就是在创建ScheduledFutureTask时，传递的周期参数不同，一个是大于0的period，一个是小于0的delay。ScheduledFutureTask的run方法运行时判断如果是周期任务，会执行runAndReset任务，执行完成后计算下次执行的时间，然后将任务重新加入工作队列。 值得注意的是如果runAndReset方法抛出异常了，那么后续的任务将不会执行。

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();
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(period));
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }

    /**
     * @throws RejectedExecutionException {@inheritDoc}
     * @throws NullPointerException       {@inheritDoc}
     * @throws IllegalArgumentException   {@inheritDoc}
     */
    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();
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(-delay));
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }

   protected boolean runAndReset() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                         null, Thread.currentThread()))
            return false;
        boolean ran = false;
        int s = state;
        try {
            Callable<V> c = callable;
            if (c != null && s == NEW) {
                try {
                    c.call(); // don't set result
                    ran = true;
                } catch (Throwable ex) {
                    setException(ex);
                }
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
        return ran && s == NEW;
    }

最后再来梳理一下和任务周期执行相关的点

1. 同一个任务的周期性执行是由period参数控制的，大于0按照fixed-rate周期执行，等于0就执行一次，小于0按照fixed-delay周期执行。fixed-rate和fixed-delay的差别是前者从第一次开始执行就确定了后续每次执行的时间。 time += period。后者每次在前一个任务执行完成后，取当前时间now+delay计算得出。

不管是fixed-rate还是fixed-delay，必须等前一个任务执行完成后，才会把这个任务再次加入工作队列。所以如果任务执行时间超过了period，那么每次开始执行任务的时间是和任务执行时间有关系的。

2. 对于同一个任务来说，如果前一个任务执行失败，后续任务将会取消

3. 如果有多个工作线程执行周期性任务，工作线程worker在从工作队列取任务getTask时，调用了工作队列的take方法取任务，这个方法是阻塞队列的操作。ScheduledFutureTask的take方法实现时，会判断队首任务的delay时间是否到期，如果没到期，worker会阻塞直到delay时间到期才能取到队首任务。

4. ScheduledThreadPoolExecutor可以执行多个周期任务，每个周期任务之间是隔离的。对同一个任务周期执行来说，满足1-3点。