ScheduledThreadPoolExecutor之scheduleWithFixedDelay和scheduleAtFixedRate的区别

结论

其实自己在看这个源码的时候，只是看到这两个方法都是周期性执行任务的，但是没有仔细去看两个方法的细节，所以，这篇笔记主要记录两者的区别
整个源码细节看下来之后，我认为这两个方法最大的一个区别是：
scheduleAtFixedRate是在上一次任务的开始时间的基础之上，加上指定的时间间隔，作为当前任务执行的开始时间
scheduleWithFixedDelay是在上一次任务执行完毕之后的基础之上，加上指定的时间间隔，作为当前任务执行的开始时间

我们假如定时执行周期都设置为5S，任务执行需要耗时2S，以这个窗口作为执行时间刻度的话，区别就是上面图中所画的这样

应用

这个代码的意思是：初始化了一个ScheduledThreadPoolExecutor，然后执行执行间隔是5S，每个任务中休眠了2S，模拟需要耗时2S的操作

scheduleAtFixedRate

public class ScheduledThreadPoolTest {public static void main(String[] args) {ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(4);SimpleDateFormat sm = new SimpleDateFormat("hh:MM:ss");System.out.println("当前时间是："+sm.format(new Date()));scheduledThreadPoolExecutor.scheduleAtFixedRate(new Runnable() {@Overridepublic void run() {try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("这是执行的内容：" + sm.format(new Date()));}}, 5, 5, TimeUnit.SECONDS);}
}

打印结果：

当前时间是：08:03:57
这是执行的内容：08:03:04
这是执行的内容：08:03:09
这是执行的内容：08:03:14
这是执行的内容：08:03:19

scheduleWithFixedDelay

public class ScheduledThreadPoolTest {public static void main(String[] args) {ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(4);SimpleDateFormat sm = new SimpleDateFormat("hh:MM:ss");System.out.println("当前时间是："+sm.format(new Date()));scheduledThreadPoolExecutor.scheduleWithFixedDelay(new Runnable() {@Overridepublic void run() {try {TimeUnit.SECONDS.sleep(2);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("这是执行的内容：" + sm.format(new Date()));}}, 5, 5, TimeUnit.SECONDS);}
}

执行结果：

当前时间是：08:03:06
这是执行的内容：08:03:13
这是执行的内容：08:03:20
这是执行的内容：08:03:27
这是执行的内容：08:03:34

根据以上两个结果可以看到，在我们指定了执行周期都是5S的情况下，scheduleAtFixedRate是以第一次任务开启的时间作为起始值 + 5S，不管这个任务执行耗时是多久，都是5S开启一次
scheduleWithFixedDelay是以第一次任务结束的时间作为起始值 + 5S，作为下一次任务开始的时间

源码

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

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

对于上面两个方法的源码，其实我们可以发现，逻辑基本是一样的，只是有一个区别：
scheduleWithFixedDelay在new ScheduledFutureTask的时候，将delay参数设置为了负数，这个区别点，就是为什么fixedDelay是以上一次任务结束时间 + 周期间隔作为下次任务开始时间的原因

1.首先是判断任务或者unit是否为null，如果true，就抛出空指针异常
2.如果执行间隔周期小于0，也抛出异常
3.然后根据当前任务和执行间隔周期值生成对应的scheduledFutureTask对象；这里其实就是对要执行的任务进行了一层封装，添加了一些额外的参数
4.将包装好的任务保存在一个全局变量中
5.delayedExecute()是将任务添加到线程池的队列中，需要注意的是：这里会添加到scheduledThreadPoolExecutor的内部队列 delayWorkQueue中

对于这么一个方法，要做的事情就完成了，那我们需要考虑下，是如何做到定时执行的？其实原理很简单，在执行任务的时候，如果需要重复执行，就再次把任务入队即可
入队之后优先级的判断，是delayWordQueue自己内部的逻辑，
那我入队了一个任务之后，是谁去取出这个任务执行的呢？
这个问题我之前一直在迷茫，结果后来才想到，scheduledThreadPoolExecutor本身就是一个线程池啊，那当然是threadPoolExecutor中的逻辑去依次取出队列中的任务去执行，只是在调用出队方法的时候，会调用delayWordQueue的出队方法
这样看起来，底层源码的设计就清晰明了的了，各个组件或者各个模块负责自己的事情，如果你要对我所负责的事情进行扩展，没关系，只要按照我的要求来就可以了

对于delayWorKQueue出队、入队之后优先级的处理就不说了，我们接着来说如何重复执行

前面有说过，对于程序员在调用了scheduleAtFixedRate()方法之后，会把要执行的任务包装成ScheduledFutureTask对象，所以，线程池在执行任务的时候，调用的也是ScheduledFutureTask的run()方法

/*** Overrides FutureTask version so as to reset/requeue if periodic.* 自定义的任务在执行的时候，实际调用的就是这个方法，因为线程池对任务进行了一层包装*/
public void run() {/*** 1.首先判断是否需要重复执行,这个值是在初始化的时候，指定的* 如果只需要执行一次，这里返回的就是false* 如果需要周期定时执行，这里返回的就是true* 根据period的值来判断*/boolean periodic = isPeriodic();/*** 2.这里没看懂，判断是否需要取消任务？*/if (!canRunInCurrentRunState(periodic))cancel(false);/*** 3.如果只需要执行一次，就会执行这里的逻辑*/else if (!periodic)ScheduledFutureTask.super.run();/*** 4.如果是需要重复执行的，就执行这里的方法* 如果任务正常执行成功，就继续设置下次的执行时间* setNextRunTime():是在当前时间的基础之上，加上第一次指定的延迟时间* reExecutePeriodic():是将任务再次加入队列中*/else if (ScheduledFutureTask.super.runAndReset()) {setNextRunTime();reExecutePeriodic(outerTask);}
}

isPeriodic()方法就是判断period是否为0
return period != 0;

那period是在什么时候赋值的呢？在new ScheduledFutureTask()的时候，这里就和上面我说 scheduleWithFixedDelay()方法，把周期执行间隔设置为负数对应上了
也就是说如果是周期执行的方法，period都不为0

runAndReset()方法是去调用程序员指定的要执行的代码块，也就是所谓的任务，执行成功之后，会接着调用两个方法

setNextRunTime()方法是设置下次任务执行时间
reExecutePeriodic()其实就是把任务再次入队

/*** Sets the next time to run for a periodic task.* 设置下次运行时间，* 如果是fixedRate,就是在当前time的基础上 + 初始化时指定的时间间隔* 如果是fixedDelay，就是在当前时间now()的基础上 + 指定的时间间隔*/
private void setNextRunTime() {long p = period;if (p > 0)time += p;elsetime = triggerTime(-p);
}

首先需要知道：
scheduleAtFixedRate方法的period是大于0的
scheduleWithFixedDelay的period是小于0的

这里可以看到，对于time(任务开始执行时间)的设置，对于p > 0的场景，是在上次任务开始时间的基础上，加上设置的执行间隔
对于p < 0的场景，是调用了triggerTime(-p);方法


/*** Returns the trigger time of a delayed action.* 在fixedDelay方法被调用的时候，如果是设置下一次执行时间，就是now() + delay*/
long triggerTime(long delay) {return now() +((delay < (Long.MAX_VALUE >> 1)) ? delay : overflowFree(delay));
}

这个判断中，就是now() + delay 因为delay一般设置的都是小于 Long.MAX_VALUE >> 1的

所以我们也可以推断出：
scheduleAtFixedRate方法是在上一次任务执行的开始时间的基础上 + 任务周期执行间隔作为下次任务开始时间
scheduleWithFixedDelay方法是在上一次任务执行完毕的时间基础上 + 任务周期执行间隔作为下次任务开始时间