定时线程池ScheduledThreadPoolExecutor

简介

ScheduledThreadPoolExecutor 继承了 ThreadPoolExecutor 并实现了ScheduledExecutorService接口 。线程池队列是DelayedWorkQueue，它和 DelayedQueue原理类似，都是一个延迟队列。在ScheduledThreadPoolExecutor中阻塞队列存储的是ScheduledFutureTask对象，它是任务真正的载体。ScheduledFutureTask对象同样可以看做Runnable对象来使用。

ScheduledExecutorService主要有四个接口

public interface ScheduledExecutorService extends ExecutorService {

    // 执行一个无返回值任务，delay代表延迟多久执行，unit为延时单位
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);

    // 执行一个有返回值任务，delay代表延迟多久执行，unit为延时单位
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);
    
    // 按固定频率执行一个任务，每 period 秒执行一次，initialDelay秒后执行
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);
    
    // 按固定延时执行一个任务，每延时delay秒执行一次，initialDelay 秒后执行
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);
}
      

内部类

// ScheduledFutureTask继承了FutureTask类，实现了RunnableScheduledFuture接口
private class ScheduledFutureTask<V>
            extends FutureTask<V> implements RunnableScheduledFuture<V> {
    	// 序列号
        private final long sequenceNumber;
    	// 延时时间
        private long time;
    	// 周期时间
        private final long period;
    	// 当前ScheduledFutureTask对象的引用，为了reExecute重新执行时可以找到对象
        RunnableScheduledFuture<V> outerTask = this;

        int heapIndex;
        // 构造函数
        ScheduledFutureTask(Runnable r, V result, long ns) {
            super(r, result);
            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();
        }
        ScheduledFutureTask(Callable<V> callable, long ns) {
            super(callable);
            this.time = ns;
            this.period = 0;
            this.sequenceNumber = sequencer.getAndIncrement();
        }
}
 // DelayedWorkQueue和DelayedQueue原理类似，都是一个延迟队列，队列的数据结构是一个小根堆
 static class DelayedWorkQueue extends AbstractQueue<Runnable>
        implements BlockingQueue<Runnable>{
 }

主要方法

// 执行一个无返回值任务，delay代表延迟多久执行，unit为延时单位
public ScheduledFuture<?> schedule(Runnable command,
                                   long delay,
                                   TimeUnit unit) {
    if (command == null || unit == null)
        throw new NullPointerException();
    // 构造一个ScheduledFutureTas对象
    RunnableScheduledFuture<?> t = decorateTask(command,
        new ScheduledFutureTask<Void>(command, null,
                                      triggerTime(delay, unit)));
    delayedExecute(t); // 将任务放进延时队列
    return t;
}

// 将任务放进延时队列
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(); // 根据情况来创建工作线程
    }
}

// ThreadPoolExecutor.ensurePrestart()
// 生成工作线程，确保有足够的线程来执行队列里面的任务
void ensurePrestart() {
    int wc = workerCountOf(ctl.get());
    // 这里没有传入firstTask参数，因为上面已经把任务扔到队列中去了
    if (wc < corePoolSize)
        addWorker(null, true); // 创建工作线程去消费队列里面的任务，该方法在讲解ThreadPoolExecutor已经分析过了
    else if (wc == 0)
        addWorker(null, false);
}

// addWorker主要是创建工作线程，然后启动线程执行Worker里面的run方法
// Worker里面的run方法的作用就是执行用户首次提交的任务以及不断地消费队列里面的任务。
// ScheduledThreadPoolExecutor使用内部类DelayedWorkQueue来存储任务，其原理与DelayedQueue类似，所以这里就不做解释了。
// 所以Worker里面的run方法从队列里面拿到的是ScheduledFutureTask任务，并执行ScheduledFutureTask的run方法

// ScheduledFutureTask.run()
public void run() {
    // 是否是周期任务
    boolean periodic = isPeriodic();
    // 对线程池的状态做一些判断
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    else if (!periodic)
        // 如果不是周期任务，直接调用父类的run方法，这里的父类是指FutureTask
        // 前面的文章已经对FutureTask的源码分析过
        ScheduledFutureTask.super.run();
    // 如果是周期性任务，先调用父类的runAndReset，runAndReset方法主要是执行任务
    // 这里的父类是指FutureTask
    else if (ScheduledFutureTask.super.runAndReset()) {
        setNextRunTime(); // 任务执行成功，则设置下一次的执行时间
        reExecutePeriodic(outerTask); // 又把任务放入队列里面
    }
}
// 计算下次任务的执行时间
// 可以看到，当period大于0时表示fixed-rate的方式周期执行，每次执行的时间是固定的，从第一次开始执行，然后每次加上period，一旦开始运行就可以计算出每次执行的时间。
// 当period小于0时，表示fixed-delay方式周期执行，每次是取当前时间 + delay，当前时间是前一个任务执行完成的时间。受到当前任务执行时间的影响。
 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));
}

// 再次将任务放进队列里面
void reExecutePeriodic(RunnableScheduledFuture<?> task) {
    if (canRunInCurrentRunState(true)) {
        super.getQueue().add(task);
        if (!canRunInCurrentRunState(true) && remove(task))
            task.cancel(false);
        else
            ensurePrestart();
    }
}

// 执行一个有返回值任务，delay代表延迟多久执行，unit为延时单位
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;
}

// 按固定频率执行一个任务，每 period 秒执行一次，initialDelay秒后执行
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; // 因为是周期性任务，所以后面需要用到outerTask再次入队
        delayedExecute(t); // 将任务放进延时队列
        return t;
    }

// 按固定延时执行一个任务，每延时delay秒执行一次，initialDelay 秒后执行
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;  // 因为是周期性任务，所以后面需要用到outerTask再次入队
        delayedExecute(t); // 将任务放进延时队列
        return t;
    }

总结

定时任务是延时队列来实现的，周期性任务是任务完成之后再把任务放到队列里面。