scheduleAtFixedRate vs scheduleWithFixedDelay

Qual è la principale differenza tra scheduleAtFixedRatee i scheduleWithFixedDelaymetodi di 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);

stampano esattamente allo stesso tempo, sembra che siano eseguiti esattamente allo stesso intervallo.

Prova ad aggiungere una Thread.sleep(1000);chiamata all'interno del tuo run()metodo ... Fondamentalmente è la differenza tra programmare qualcosa in base a quando termina l' esecuzione precedente e quando (logicamente) inizia .

Ad esempio, supponiamo che io programmi una sveglia in modo che si attivi con una frequenza fissa di una volta ogni ora, e ogni volta che suona, bevo una tazza di caffè, che impiega 10 minuti. Supponiamo che inizi a mezzanotte, avrei:

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

Se pianifico con un ritardo fisso di un'ora, avrei:

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

Quale vuoi dipende dal tuo compito.

Visualizza le serie temporali del scheduleAtFixedRatemetodo di invocazione . Le esecuzioni successive inizieranno immediatamente se l'ultima impiega più del periodo. Altrimenti, inizierà dopo il periodo di tempo.

Serie temporale del scheduleWithFixedDelaymetodo di chiamata . La prossima esecuzione inizierà dopo il tempo di ritardo tra la fine di un'esecuzione e l'inizio della successiva, indipendentemente dal tempo di esecuzione

La speranza può aiutarti

Il scheduleAtFixedRate()metodo crea una nuova attività e la invia all'esecutore ogni periodo, indipendentemente dal fatto che l'attività precedente sia terminata o meno .

D'altra parte, il scheduleWithFixedDelay()metodo crea una nuova attività al termine dell'attività precedente .

Se leggi il documento Java sarà più chiaro

ScheduledFuture scheduleAtFixedRate (Comando eseguibile, long initialDelay, long period, unità TimeUnit) Crea ed esegue un'azione periodica che viene abilitata prima dopo il ritardo iniziale specificato e successivamente con il periodo specificato; cioè le esecuzioni inizieranno dopo initialDelay, quindi initialDelay + period, quindi initialDelay + 2 * period e così via.

ScheduledFuture scheduleWithFixedDelay (Comando eseguibile, long initialDelay, long delay, TimeUnit unit) Crea ed esegue un'azione periodica che viene abilitata prima dopo il ritardo iniziale specificato e successivamente con il ritardo dato tra la fine di un'esecuzione e l'inizio di quella successiva.

C'è un problema in scheduleAtFixedRate se il primo thread sta impiegando troppo tempo e non è terminato in una data durata, il secondo thread consecutivo non si avvierà una volta terminata la prima attività e non verrà avviato immediatamente mentre il primo thread ha completato il compito e la durata del gievn è trascorso. JVM deciderà quando verrà eseguita la prossima attività.

Penso che ti aiuterà a scegliere il metodo perché a causa di questo ho un grosso problema

Scriviamo un semplice programma:

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)

E guarda i risultati:

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

AVVISO il tempo di esecuzione è maggiore dell'attesa

scheduleWithFixedDelay mantiene il ritardo
scheduleAtFixedRate rimuove il ritardo

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

Eseguilo e conoscerai la differenza. Grazie