ScheduleAtFixedRate vs ScheduleWithFixedDelay

Was ist der Hauptunterschied zwischen scheduleAtFixedRateundscheduleWithFixedDelay Methoden von 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);

Sie drucken genau zur gleichen Zeit und scheinen genau im gleichen Intervall ausgeführt zu werden.

Versuchen Sie, einen Thread.sleep(1000);Aufruf innerhalb Ihrer run()Methode hinzuzufügen ... Grundsätzlich ist es der Unterschied zwischen dem Planen von etwas basierend darauf, wann die vorherige Ausführung endet und wann sie (logisch) beginnt .

Angenommen, ich plane einen Alarm mit einer festen Rate von einmal pro Stunde und jedes Mal , wenn er ausgelöst wird, trinke ich eine Tasse Kaffee, was 10 Minuten dauert. Angenommen, das beginnt um Mitternacht, ich hätte:

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

Wenn ich mit einer festen Verzögerung von einer Stunde plane, hätte ich:

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

Welches Sie wollen, hängt von Ihrer Aufgabe ab.

Visualisieren Sie Zeitreihen der Aufrufmethode scheduleAtFixedRate. Die nächsten Ausführungen beginnen sofort, wenn die letzte länger als die Dauer dauert. Andernfalls wird es nach Ablauf der Zeit gestartet.

Zeitreihen der Aufrufmethode scheduleWithFixedDelay. Die nächste Ausführung beginnt nach der Verzögerungszeit zwischen der Beendigung einer Ausführung und dem Beginn der nächsten, unabhängig von ihrer Ausführungszeit

Hoffnung kann dir helfen

Die scheduleAtFixedRate()Methode erstellt eine neue Aufgabe und sendet sie in jedem Zeitraum an den Executor, unabhängig davon, ob die vorherige Aufgabe abgeschlossen wurde oder nicht .

Andererseits erstellt die scheduleWithFixedDelay()Methode eine neue Aufgabe, nachdem die vorherige Aufgabe abgeschlossen wurde .

Wenn Sie das Java-Dokument lesen, wird es klarer

ScheduledFuture ScheduleAtFixedRate (ausführbarer Befehl, lange Anfangsverzögerung, langer Zeitraum, TimeUnit-Einheit) Erstellt eine periodische Aktion und führt sie aus, die erst nach der angegebenen anfänglichen Verzögerung und anschließend mit dem angegebenen Zeitraum aktiviert wird. Das heißt, die Ausführung beginnt nach initialDelay, dann nach initialDelay + period, dann nach initialDelay + 2 * und so weiter.

ScheduledFuture ScheduleWithFixedDelay (Runnable-Befehl, Long InitialDelay, Long Delay, TimeUnit-Einheit) Erstellt und führt eine periodische Aktion aus, die erst nach der angegebenen Anfangsverzögerung und anschließend mit der angegebenen Verzögerung zwischen der Beendigung einer Ausführung und dem Beginn der nächsten aktiviert wird.

Es gibt einen Haken in ScheduleAtFixedRate. Wenn der erste Thread zu lange dauert und nicht in der angegebenen Dauer beendet wird, startet der zweite fortlaufende Thread nicht, sobald die erste Aufgabe abgeschlossen ist, und startet nicht sofort, während der erste Thread seine Aufgabe und die angegebene Dauer erreicht hat wurde abgelaufen. JVM entscheidet, wann die nächste Aufgabe ausgeführt wird.

Ich denke, das wird dir helfen, die Methode zu wählen, weil ich aus diesem Grund ein großes Problem habe

Schreiben wir ein einfaches Programm:

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)

Und sehen Sie die Ergebnisse:

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

HINWEIS Die Ausführungszeit ist länger als das Warten

ScheduleWithFixedDelay behält die Verzögerung bei
ScheduleAtFixedRate entfernt die Verzögerung

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

Führen Sie es einfach aus, und Sie werden den Unterschied kennen. Danke dir