ScheduledExecutorService中scheduleAtFixedRate方法与scheduleWithFixedDelay方法的区别

ScheduledThreadPoolExecutor继承自ThreadPoolExecutor,可以作为线程池来使用，同时实现了ScheduledExecutorService接口，来执行一些周期性的任务。ScheduledExecutorService一般常用的方法主要就4个
```
    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);
```
两个schedule方法都很明确，就是执行一次Runnable、Callable任务。

scheduleAtFixedRate和scheduleWithFixedDelay这两个方法看起来就不是那么好区分了，今天就带大家从源码角度看看这两个方法的区别.
我们先看看这两个方法的区别

下面是这两个方法的源码

从上面的图上可以看到唯一的不同就是在创建ScheduledFutureTask对象的时候，scheduleWithFixedDelay将我们传入的delay取了个负数。所以这两个方法的区别都会在ScheduledFutureTask这个类中。

先说下ScheduledFutureTask这个类吧，它是ScheduledThreadPoolExecutor的内部类，我们看下它的继承关系

从上图中能看到ScheduledFutureTask，间接继承了Runnable接口，会实现run方法。而我们ScheduledThreadPoolExecutor类中真正执行任务的类其实也就是调用ScheduledFutureTask的run方法。也间接实现了Comparable接口的比较方法。

下面以scheduleAtFixedRate看看内部调用逻辑

    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,

                                                  long initialDelay,

                                                  long period,

                                                  TimeUnit unit) {

        if (command == null || unit == null)

            throw new NullPointerException();

        if (period <= 0L)

            throw new IllegalArgumentException();

        ScheduledFutureTask<Void> sft =

            new ScheduledFutureTask<Void>(command,

                                          null,

                                          //这里是计算首次执行实现

                                          triggerTime(initialDelay, unit),

                                          unit.toNanos(period),

                                          sequencer.getAndIncrement());

        //这里当前是直接返回的上面的sft,这个是留给子类去扩展的

        RunnableScheduledFuture<Void> t = decorateTask(command, sft);

        sft.outerTask = t;

        //所以这里也就是把上面创建的ScheduledFutureTask加到线程池的任务队列中去

        delayedExecute(t);

        return t;

    }

这里是ScheduledFutureTask的构造方法

        ScheduledFutureTask(Runnable r, V result, long triggerTime,

                            long period, long sequenceNumber) {

            super(r, result);

            //这个是任务首次执行的时间

            this.time = triggerTime;

            //这里的代码很简单，只是将它赋值给了成员变量period。

            //其中scheduleWithFixedDelay是在外面取了个负数传了进来，scheduleAtFixedRate则是原样传了进来

            this.period = period;

            //这个是AtomicLong类型的，每次都+1，对我们加入的任务做了个编号

            this.sequenceNumber = sequenceNumber;

        }

我们再看看delayedExecute(t);的内部

    private void delayedExecute(RunnableScheduledFuture<?> task) {

        if (isShutdown())

            reject(task);

        else {

            //重点在这里，这里会把上面的ScheduledFutureTask加入到线程池的任务队列中，

            //这里的super.getQueue()这个队列，是在ScheduledThreadPoolExecutor构造方法中定义的，也是ScheduledThreadPoolExecutord的内部类，类名是DelayedWorkQueue

            //DelayedWorkQueue其实是一个最小堆，会对加入它的元素，调用compareTo方法进行排序，首个元素是最小的

            //对应当前这里，就是调用ScheduledFutureTask的compareTo方法进行排序，也就是队列中的任务是按照执行时间的先后顺序排序的

            //最终线程池执行任务的时候从首部依次获取task,具体获取任务的时候，DelayedWorkQueue会首先获取任务，查看对应的执行时间，如果任务时间没有到，就会调用Condition.awaitNanos去暂停，直到到达执行时间或者通过给队列中添加任务调用Condition.signal去唤醒

            super.getQueue().add(task);

            if (!canRunInCurrentRunState(task) && remove(task))

                task.cancel(false);

            else

                //这里是根据线程池当前的线程数，如果小于核心线程数，就会新启动线程去执行任务

                ensurePrestart();

        }

    }

上面已经可以看到把任务已经加到线程池中去了，后面就是具体由线程池去执行任务了，所以我们直接去ScheduledFutureTask查看run方法就可以了

        public void run() {

            if (!canRunInCurrentRunState(this))

                cancel(false);

            else if (!isPeriodic())

                super.run();

            //具体在这里会调用我们传入的run方法

            else if (super.runAndReset()) {

                //在这里会更新成员变量time，scheduleAtFixedRate和scheduleWithFixedDelay的区别也全在这里了，下面我们去看看这里

                setNextRunTime();

                //这里会重新将outerTask加入到线程池的任务队列中，这里的outerTask==我们当前执行run方法的对象this

                reExecutePeriodic(outerTask);

            }

        }

    }

通过上面的代码也能看到，我们的run方法是不会同时由多次执行的,举个例子，如果我们调用scheduleAtFixedRate或者scheduleWithFixedDelay方法，传入的Runnable的对象，需要执行10s，而我们设定的周期是2s，是不会在第一次Runnable的10s的周期任务启动后2s，就启动第2次周期任务的。它只会在第一个Runnable的10s的周期任务结束后，重新加入到任务队列中之后，才会启动下次的任务。

    private void setNextRunTime() {

        //这里的period ，scheduleAtFixedRate传入的是正数，scheduleWithFixedDelay传入的是负数

        long p = period;

        if (p > 0)

            //所以scheduleAtFixedRate会走这里，这里的time开始时时首次任务的开始执行时间，所以下次任务的时间就是(开始添加任务时计算出来的首次任务执行时间(这个时间不一定是任务首次执行的真正时间)+(任务执行次数-1)*period)

            time += p;

        else

            //这里对p取负，就会还原成正数，也就是我们最初调用scheduleWithFixedDelay时传入的值,这里的下次执行时间会用当前系统时间(可以看成当前Runnable执行的结束时间)+period来设置

            time = triggerTime(-p);

    }

结论

scheduleAtFixedRate或者scheduleWithFixedDelay对于从第2次开始的任务的计算时间不一样：
- scheduleAtFixedRate 下次任务的时间=(开始添加任务时计算出来的首次任务执行时间+(任务执行次数-1)*period
- scheduleWithFixedDelay 下次任务的时间=当前任务结束时间+period
需要注意的是，下次任务时间都只是计算出来的理论值，如果任务的执行时间大于周期任务的period,或者设置的线程池中线程太少，就会出现下次任务执行时间<时间任务执行时间

巴特西

ScheduledExecutorService中scheduleAtFixedRate方法与scheduleWithFixedDelay方法的区别

ScheduledExecutorService中scheduleAtFixedRate方法与scheduleWithFixedDelay方法的区别

最新文章

热门文章