阅读 4399

并发编程 —— ScheduledThreadPoolExecutor

1. 前言

在前面的文章中,我们介绍了定时任务类 Timer ,他是 JDK 1.3 中出现的,位于 java.util 包下。而今天说的 ScheduledThreadPoolExecutor的是在 JUC 包下,是 JDK1.5 新增的。

今天就来说说这个类。

2. API 介绍

该类内部结构和 Timer还是有点类似的,也是 3 个类:

  • ScheduledThreadPoolExecutor:程序员使用的接口。
  • DelayedWorkQueue : 存储任务的队列。
  • ScheduledFutureTask : 执行任务的线程。

构造方法介绍

// 使用给定核心池大小创建一个新 ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor(int corePoolSize)  
// 使用给定初始参数创建一个新 ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor(int corePoolSize, RejectedExecutionHandler handler)  
// 使用给定的初始参数创建一个新 ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory)  
// 使用给定初始参数创建一个新 ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory, RejectedExecutionHandler handler)  
复制代码

ScheduledThreadPoolExecutor最多支持 3 个参数:核心线程数量,线程工厂,拒绝策略。

为什么没有最大线程数量?由于 ScheduledThreadPoolExecutor 内部是个无界队列,maximumPoolSize 也就没有意思了。

再介绍一下他的 API 方法,请原谅我将 JDK 文档照抄过来了,就当是备忘吧,如下:

protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> callable, RunnableScheduledFuture<V> task) // 修改或替换用于执行 callable 的任务。
  
protected <V> RunnableScheduledFuture<V> decorateTask(Runnable runnable, RunnableScheduledFuture<V> task) // 修改或替换用于执行 runnable 的任务。        
    
void execute(Runnable command) // 使用所要求的零延迟执行命令。  

boolean	getContinueExistingPeriodicTasksAfterShutdownPolicy() // 获取有关在此执行程序已 shutdown 的情况下、是否继续执行现有定期任务的策略。      
   
boolean	getExecuteExistingDelayedTasksAfterShutdownPolicy() // 获取有关在此执行程序已 shutdown 的情况下是否继续执行现有延迟任务的策略。  

BlockingQueue<Runnable>	getQueue() // 返回此执行程序使用的任务队列。     

boolean	remove(Runnable task) // 从执行程序的内部队列中移除此任务(如果存在),从而如果尚未开始,则其不再运行。     
  
<V> ScheduledFuture<V>	schedule(Callable<V> callable, long delay, TimeUnit unit) // 创建并执行在给定延迟后启用的 ScheduledFuture。    
    
ScheduledFuture<?>	schedule(Runnable command, long delay, TimeUnit unit) // 创建并执行在给定延迟后启用的一次性操作。  
     
ScheduledFuture<?>	scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) // 创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;也就是将在 initialDelay 后开始执行,然后在 initialDelay+period 后执行,接着在 initialDelay + 2 * period 后执行,依此类推。 
     
ScheduledFuture<?>	scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) // 创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。  
   
void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) // 设置有关在此执行程序已 shutdown 的情况下是否继续执行现有定期任务的策略。  
   
void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) // 设置有关在此执行程序已 shutdown 的情况下是否继续执行现有延迟任务的策略。  
      
void shutdown() // 在以前已提交任务的执行中发起一个有序的关闭,但是不接受新任务。
    
List<Runnable>	shutdownNow() // 尝试停止所有正在执行的任务、暂停等待任务的处理,并返回等待执行的任务列表。  
     
<T> Future<T> submit(Callable<T> task) //  提交一个返回值的任务用于执行,返回一个表示任务的未决结果的 Future。 
   
Future<?> submit(Runnable task) //  提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。  
     
<T> Future<T> submit(Runnable task, T result) //  提交一个 Runnable 任务用于执行,并返回一个表示该任务的 Future。
复制代码

最经常使用的几个方法如下:

// 使用给定核心池大小创建一个新 ScheduledThreadPoolExecutor。
ScheduledThreadPoolExecutor(int corePoolSize)  

// 创建并执行在给定延迟后启用的一次性操作。  
ScheduledFuture<?>	schedule(Runnable command, long delay, TimeUnit unit) 
  
// 创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;也就是将在 initialDelay 后开始执行,然后在 initialDelay+period 后执行,接着在 initialDelay + 2 * period 后执行,依此类推。 
ScheduledFuture<?>	scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 

// 创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。       
ScheduledFuture<?>	scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 
复制代码

除了默认的构造方法,还有 3 个 schedule 方法。我们将分析他们内部的实现。

3. 构造方法内部实现

public ScheduledThreadPoolExecutor(int corePoolSize) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue());
}
复制代码

我们感兴趣的就是这个 DelayedWorkQueue 队列了。他也是一个阻塞队列。这个队列的数据结构是堆。同时,这个 queue 也是可比较的,比较什么呢?任务必须实现 compareTo 方法,这个方法的比较逻辑是:比较任务的执行时间,如果任务的执行时间相同,则比较任务的加入时间。

因此,ScheduledFutureTask 有 2 个变量:

  • time : 任务的执行时间。
  • sequenceNumber:任务的加入时间。

这两个变量就是用来比较任务的执行顺序的。整个调度的顺序就是这个逻辑。

4. 几个 schedule 方法的的区别

刚刚说了,有 3 个 schedule 方法:

  1. ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) 创建并执行在给定延迟后启用的一次性操作。

  2. ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作,后续操作具有给定的周期;也就是将在initialDelay 后开始执行,然后在 initialDelay+period后执行,接着在initialDelay + 2 * period后执行,依此类推。

  3. ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) 创建并执行一个在给定初始延迟后首次启用的定期操作,随后,在每一次执行终止和下一次执行开始之间都存在给定的延迟。

第一个方法执行在给定的时间后,执行一次就结束。

有点意思的地方是 第二个方法和 第三个方法,他们直接的区别。

这两个方法都可以重复的调用。但是,重复调用的逻辑有所区别,这里就是比 Timer 好用的地方。

他们的共同点在于:必须等待上个任务执行完毕才能执行下个任务。

不同点在于:他们调度的时间粗略是不同的。

scheduleAtFixedRate 方法的执行周期都是固定的,也就是,他是以上一个任务的开始执行时间作为起点,加上之后的 period 时间,调度下次任务。

scheduleWithFixedDelay 方法则是以上一个任务的结束时间作为起点,加上之后的 period 时间,调度下次任务。

有什么区别呢?

如何任务执行时间很短,那就没上面区别。但是,如果任务执行时间很长,超过了 period 时间,那么区别就出来了。

我们假设一下。

我们设置 period 时间为 2 秒,而任务耗时 5 秒。

这个两个方法的区别就体现出来了。

scheduleAtFixedRate 方法将会在上一个任务结束完毕立刻执行,他和上一个任务的开始执行时间的间隔是 5 秒(因为必须等待上一个任务执行完毕)。

scheduleWithFixedDelay 方法将会在上一个任务结束后,注意:**再等待 2 秒,**才开始执行,那么他和上一个任务的开始执行时间的间隔是 7 秒。

所以,我们在使用 ScheduledThreadPoolExecutor 的过程中需要注意任务的执行时间不能超过间隔时间,如果超过了,最好使用scheduleAtFixedRate 方法,防止任务堆积。

当然,也和具体的业务有关。不能一概而论。但一定要注意这两个方法的区别。

5. scheduled 方法的实现

我们看看 scheduleAtFixedRate 方法的内部实现。

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;
}
复制代码

创建一个 ScheduledFutureTask 对象,然后装饰一个这个Future ,该类实现是直接返回,子类可以有自己的实现,在这个任务外装饰一层。

然后执行 delayedExecute 方法,最后返回 Future

这个 ScheduledFutureTask 实现了很多接口,比如 FutureRunnableComparableDelayed 等。

ScheduledFutureTask 的构造方法如下:

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

public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

public static <T> Callable<T> callable(Runnable task, T result) {
    if (task == null)
        throw new NullPointerException();
    return new RunnableAdapter<T>(task, result);
}

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

层层递进,该类首先通过一个原子静态 int对象这只任务的入队编号,然后创建一个 Callable,这个 Callable 是一个适配器,适配了RunnableCallable,也就是将Runnable包装成 callabe, 他的 call方法就是调用给定任务的 run 方法。当然,这里的 result是没有什么作用的。

如果你传递的是一个 callable ,那么,就调用 FutureTaskrun方法,设置真正的返回值。

这里使用了适配器模式,还是挺有趣的。

总的来说,这个 ScheduledFutureTask 基于 FutureTask, 关于 FutureTask 我们之前从源码介绍过了。

而他自己重写了几个方法:compareTogetDelayrunisPeriodic4 个方法。

我们还是要看看 delayedExecute 的实现。

private void delayedExecute(RunnableScheduledFuture<?> task) {
    if (isShutdown())
        reject(task);
    else {
        // 添加进队列。
        super.getQueue().add(task);
        // 如果线程池关闭了,且不可以在当前状态下运行任务,且从队列删除任务成功,就给任务打上取消标记。
        // 第二个判断是由两个变量控制的(下面是默认值):
        // continueExistingPeriodicTasksAfterShutdown = false 表示关闭的时候应取消周期性任务。默认关闭
        // executeExistingDelayedTasksAfterShutdown = true。表示关闭的时候应取消非周期性的任务。默认不关闭。
        // running 状态下,canRunInCurrentRunState 必定返回 ture。
        // 非 running 状态下,canRunInCurrentRunState 根据上面的两个值返回。
        if (isShutdown() &&
            !canRunInCurrentRunState(task.isPeriodic()) &&
            remove(task))
            task.cancel(false);
        else
            // 开始执行任务
            ensurePrestart();
    }
}
复制代码

说说上面的方法。

  1. 判断是否关闭,关闭则拒绝任务。
  2. 如果不是 关闭状态,则添加进队列,而添加队列的顺序我们之前讲过了,根据 ScheduledFutureTaskcompareTo 方法来的,先比较执行时间,再比较添加顺序。
  3. 如果这个过程中线程池关闭了,则判断此时是否应该取消任务,根据两个变量来的,注释里面写了。默认的策略是,如果是周期性的任务,就取消,反之不取消。
  4. 如果没有关闭线程池。就调用线程池里的线程执行任务。

整体的过程如图:

image.png

注意上面的图,如果是周期性的任务,则会在执行完毕后,归还队列。

从哪里可以看出来呢?

ScheduledFutureTaskrun 方法:

public void run() {
    // 是否是周期性任务
    boolean periodic = isPeriodic();
    // 如果不可以在当前状态下运行,就取消任务(将这个任务的状态设置为CANCELLED)。
    if (!canRunInCurrentRunState(periodic))
        cancel(false);
    // 如果不是周期性的任务,调用 FutureTask # run 方法
    else if (!periodic)
        ScheduledFutureTask.super.run();
    // 如果是周期性的。
    // 执行任务,但不设置返回值,成功后返回 true。(callable 不可以重复执行)
    else if (ScheduledFutureTask.super.runAndReset()) {
        // 设置下次执行时间
        setNextRunTime();
        // 再次将任务添加到队列中
        reExecutePeriodic(outerTask);
    }
}
复制代码

逻辑如下:

  1. 如果不能再当前状态下运行了,就取消这个任务。
  2. 如果不是周期性的任务,就执行 FutureTaskrun 方法。
  3. 如果是周期性的任务,就需要执行 runAndReset方法。
  4. 执行完毕后,重写设置当前任务的下次执行时间,然后添加进队列中。

而管理整个执行过程的就是ScheduledThreadPoolExecutor的父类 ThreadPoolExecutorrunWorker方法。其中,该方法会从队列中取出数据,也就是调用队列的 take 方法。

关于DelayedWorkQueuetake方法,其中有个 leader 变量,如果 leader 不是空,说明已经有线程在等待了,那就阻塞当前线程,如果是空,说明,队列的第一个元素已经被更新了,就设置当前线程为 leader.

这是一个 Leader-Follower 模式,Doug Lea 说的。

当然,take方法整体的逻辑还是不变的。从队列的头部拿数据。使用 Condition 做线程之间的协调。

5. 总结

关于 ScheduledThreadPoolExecutor 调度类,我们分析的差不多了,总结一下。

ScheduledThreadPoolExecutor 是个定时任务线程池,类似 Timer,但是比 Timer强大,健壮。

比如不会像 Timer 那样,任务异常了,整个调度系统就彻底无用了。

也比Timer 多了Rate 模式(Rate 和 Delay)。

这两种模式的区别就是任务执行的起点时间不同,Rate是从上一个任务的开始执行时间开始计算;Delay 是从上一个任务的结束时间开始计算。

因此,如果任务本身的时间超过了间隔时间,那么这两种模式的间隔时间将会不一致。

而任务的排序是通过 ScheduledFutureTaskcompareTo方法排序的,规则是先比较执行时间,如果时间相同,再比较加入时间。

还要注意一点就是:如果任务执行过程中异常了,那么将不会再次重复执行。因为 ScheduledFutureTaskrun方法没有做catch处理。所以程序员需要手动处理,相对于 Timer 异常就直接费了调度系统来说,要好很多。

ScheduledThreadPoolExecutor 的是实现基于 ThreadPoolExecutor,大部分功能都是重用的父类,只是自己在执行完毕之后,重新设置时间,并再次将任务还到了队列中,形成了定时任务。