scheduleAtFixedRate против scheduleWithFixedDelay

Что главное различие между scheduleAtFixedRateи scheduleWithFixedDelayметодами ScheduledExecutorService ?

scheduler.scheduleAtFixedRate(new Runnable() {
    @Override
    public void run() {
        System.out.println("scheduleAtFixedRate:    " + new Date());
    }
}, 1, 3L , SECONDS);

scheduler.scheduleWithFixedDelay(new Runnable() {
    @Override
    public void run() {
        System.out.println("scheduleWithFixedDelay: " + new Date());
    }
}, 1, 3L , SECONDS);

они печатают точно в одно и то же время, кажется, они выполняются с точно таким же интервалом.

Попробуйте добавить Thread.sleep(1000);вызов в свой run()метод ... В основном это разница между планированием чего-либо на основе того, когда заканчивается предыдущее выполнение, и когда оно (логически) начинается .

Например, предположим, что я планирую срабатывать будильник с фиксированной частотой один раз в час, и каждый раз, когда он срабатывает , я выпиваю чашку кофе, что занимает 10 минут. Предположим, что это начнется в полночь, у меня будет:

00:00: Start making coffee
00:10: Finish making coffee
01:00: Start making coffee
01:10: Finish making coffee
02:00: Start making coffee
02:10: Finish making coffee

Если я планирую с фиксированной задержкой в один час, у меня будет:

00:00: Start making coffee
00:10: Finish making coffee
01:10: Start making coffee
01:20: Finish making coffee
02:20: Start making coffee
02:30: Finish making coffee

Какой из них вы хотите, зависит от вашей задачи.

Визуализируйте временной ряд scheduleAtFixedRateметода вызова . Следующие казни начнутся немедленно, если последнее длится дольше периода. В противном случае он начнется по истечении определенного периода времени.

Временной ряд scheduleWithFixedDelayметода вызова . Следующее выполнение начнется по истечении времени задержки между завершением одного выполнения и началом следующего, независимо от времени его выполнения.

Надеюсь помочь тебе

scheduleAtFixedRate()Метод создает новую задачу и передает его исполнителю за каждый период, независимо от того , или не закончили предыдущее задание .

С другой стороны, scheduleWithFixedDelay()метод создает новую задачу после завершения предыдущей .

Если вы прочитаете Java Doc, будет понятнее

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) Создает и выполняет периодическое действие, которое активируется сначала после заданной начальной задержки, а затем с заданной задержкой между завершением одного выполнения и началом следующего.

В scheduleAtFixedRate есть одна загвоздка, если первый поток занимает слишком много времени и не завершился в течение заданного времени, тогда второй последовательный поток не запустится, как только первая задача будет завершена, и не будет немедленно запущен, пока первый поток завершил свою задачу и продолжительность gievn истекло. JVM решит, когда будет выполнена следующая задача.

Думаю, это поможет вам выбрать метод Becuase, в связи с чем у меня возникла большая проблема

Напишем простую программу:

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

var time = 0L
var start = System.currentTimeMillis()
val executor = Executors.newScheduledThreadPool(1)
executor.scheduleWithFixedDelay({
    if (time >= 12_000L) {
        executor.shutdown()
    } else {
        Thread.sleep(2000L)
        val now = System.currentTimeMillis()
        time += now - start
        System.out.println("Total $time delay ${now - start}\n")
        start = now
    }
}, 0L, 1000L, TimeUnit.MILLISECONDS)

И посмотрите результаты:

| scheduleWithFixedDelay |   scheduleAtFixedRate  |
|:----------------------:|:----------------------:|
| Total 2001 delay 2001  | Total 2003 delay 2003  |
| Total 5002 delay 3001  | Total 4004 delay 2001  |
| Total 8003 delay 3001  | Total 6004 delay 2000  |
| Total 11003 delay 3000 | Total 8004 delay 2000  |
| Total 14003 delay 3000 | Total 10005 delay 2001 |
|          ---           | Total 12005 delay 2000 |

ВНИМАНИЕ, время выполнения больше, чем ожидание

scheduleWithFixedDelay сохраняет задержку
scheduleAtFixedRate удаляет задержку

scheduledExecutorService.scheduleAtFixedRate(() -> {
        System.out.println("runnable start"); try { Thread.sleep(5000);  System.out.println("runnable end");} catch
     (InterruptedException e) { // TODO Auto-generated catch block
      e.printStackTrace(); }}, 2, 7, TimeUnit.SECONDS);



     scheduledExecutorService.scheduleWithFixedDelay(() -> {
     System.out.println("runnable start"); try { Thread.sleep(5000); System.out.println("runnable end");} catch
     (InterruptedException e) { // TODO Auto-generated catch block
     e.printStackTrace(); } }, 2, 7, TimeUnit.SECONDS);

Просто выполните его, и вы почувствуете разницу. Спасибо