scheduleAtFixedRate vs scheduleWithFixedDelay

¿Cuál es la principal diferencia entre los métodos scheduleAtFixedRatey scheduleWithFixedDelayde 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);

imprimen exactamente al mismo tiempo, parece que se ejecutan exactamente en el mismo intervalo.

Intente agregar una Thread.sleep(1000);llamada dentro de su run()método ... Básicamente, es la diferencia entre programar algo en función de cuándo termina la ejecución anterior y cuándo comienza (lógicamente) .

Por ejemplo, supongamos que programo una alarma para que suene con una frecuencia fija de una vez por hora, y cada vez que suena, tomo una taza de café, que tarda 10 minutos. Supongamos que comienza a la medianoche, tendría:

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 programo con un retraso fijo de una hora, tendría:

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

Cuál quieres depende de tu tarea.

Visualice series de tiempo del scheduleAtFixedRatemétodo de invocación . Las siguientes ejecuciones comenzarán inmediatamente si la última lleva más de un período. De lo contrario, comenzará después del período de tiempo.

Serie temporal del scheduleWithFixedDelaymétodo de invocación . La siguiente ejecución comenzará después del tiempo de demora entre la terminación de una ejecución y el comienzo de la siguiente, independientemente de su tiempo de ejecución.

La esperanza puede ayudarte

El scheduleAtFixedRate()método crea una nueva tarea y la envía al ejecutor cada período, independientemente de si la tarea anterior terminó o no .

Por otro lado, el scheduleWithFixedDelay()método crea una nueva tarea una vez finalizada la anterior .

Si lee Java Doc, será más claro

ScheduledFuture scheduleAtFixedRate (Comando ejecutable, retraso inicial largo, período largo, unidad TimeUnit) Crea y ejecuta una acción periódica que se habilita primero después del retraso inicial dado, y luego con el período dado; es decir, las ejecuciones comenzarán después de initialDelay, luego initialDelay + período, luego initialDelay + 2 * período, y así sucesivamente.

ScheduledFuture scheduleWithFixedDelay (comando ejecutable, retraso inicial largo, retraso largo, unidad TimeUnit) Crea y ejecuta una acción periódica que se habilita primero después del retraso inicial dado, y posteriormente con el retraso dado entre la terminación de una ejecución y el comienzo de la siguiente.

Hay un problema en scheduleAtFixedRate si el primer hilo está tardando demasiado y no finaliza en una duración determinada, entonces el segundo hilo consecutivo no se iniciará una vez que la primera tarea haya finalizado y no se iniciará inmediatamente mientras el primer hilo haya completado su tarea y haya alcanzado la duración ha transcurrido. JVM decidirá cuándo se ejecutará la siguiente tarea.

Creo que eso te ayudará a elegir el método porque debido a esto tengo un gran problema

Escribamos un programa 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)

Y mira los resultados:

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

AVISO el tiempo de ejecución es mayor que esperar

scheduleWithFixedDelay mantiene la demora
scheduleAtFixedRate elimina la demora

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

Simplemente ejecútelo y sabrá la diferencia. Gracias