scheduleAtFixedRate vs scheduleWithFixedDelay

Quelle est la principale différence entre scheduleAtFixedRateet les scheduleWithFixedDelayméthodes de 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);

ils impriment exactement au même moment, semblent être exécutés exactement au même intervalle.

Essayez d'ajouter un Thread.sleep(1000);appel dans votre run()méthode ... Fondamentalement, c'est la différence entre planifier quelque chose en fonction du moment où l'exécution précédente se termine et du moment où elle démarre (logiquement) .

Par exemple, supposons que je programme une alarme pour qu'elle se déclenche avec un taux fixe d'une fois par heure et que chaque fois qu'elle se déclenche, je prends une tasse de café, ce qui prend 10 minutes. Supposons que cela commence à minuit, j'aurais:

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

Si je programme avec un délai fixe d'une heure, j'aurais:

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

Celui que vous voulez dépend de votre tâche.

Visualisez la série chronologique de la scheduleAtFixedRateméthode d' appel . Les prochaines exécutions commenceront immédiatement si la dernière prend plus de temps que la période. Sinon, il démarrera après la période.

Série chronologique de la scheduleWithFixedDelayméthode d' appel . La prochaine exécution commencera après un délai entre la fin d'une exécution et le début de la suivante, indépendamment de son heure d'exécution

L'espoir peut vous aider

La scheduleAtFixedRate()méthode crée une nouvelle tâche et la soumet à l'exécuteur à chaque période, que la tâche précédente soit terminée ou non .

D'autre part, la scheduleWithFixedDelay()méthode crée une nouvelle tâche une fois la tâche précédente terminée .

Si vous lisez le Java Doc, ce sera plus clair

ScheduledFuture scheduleAtFixedRate (Commande exécutable, long initialDelay, longue période, unité TimeUnit) Crée et exécute une action périodique qui devient activée en premier après le délai initial donné, puis avec la période donnée; c'est-à-dire que les exécutions commenceront après initialDelay puis initialDelay + period, puis initialDelay + 2 * period, et ainsi de suite.

ScheduledFuture scheduleWithFixedDelay (commande Runnable, long initialDelay, long delay, TimeUnit unit) Crée et exécute une action périodique qui devient activée d'abord après le délai initial donné, puis avec le délai donné entre la fin d'une exécution et le début de la suivante.

Il y a un problème dans scheduleAtFixedRate si le premier thread prend trop de temps et n'est pas terminé dans une durée donnée, le second thread conscutif ne démarrera pas une fois que la première tâche sera terminée et ne démarrera pas immédiatement tant que le premier thread a terminé sa tâche et sa durée s'est écoulé. JVM décidera quand la prochaine tâche sera exécutée.

Je pense que cela vous aidera à choisir la méthode car à cause de cela, j'ai un gros problème

Écrivons un programme simple:

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)

Et voyez les résultats:

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

AVIS le temps d'exécution est plus long que l'attente

scheduleWithFixedDelay conserve le délai de
programmationAtFixedRate supprime le délai

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

Exécutez-le simplement et vous saurez la différence. Je vous remercie