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

2021-08-29 22:14 wang03 阅读(147) 评论(0) 编辑收藏举报

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,或者设置的线程池中线程太少，就会出现下次任务执行时间<时间任务执行时间

标签 java

秒客网

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

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

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

相关文章