scheduleAtFixedRate vs scheduleWithFixedDelay

Qual é a principal diferença entre scheduleAtFixedRatee scheduleWithFixedDelaymétodos 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);

eles imprimem exatamente ao mesmo tempo, parece que são executados exatamente no mesmo intervalo.

Tente adicionar uma Thread.sleep(1000);chamada dentro do seu run()método ... Basicamente, é a diferença entre agendar algo baseado em quando a execução anterior termina e quando ela (logicamente) começa .

Por exemplo, suponha que eu programe um alarme para disparar a uma taxa fixa de uma vez por hora e, toda vez que ele disparar, tomo uma xícara de café, o que leva 10 minutos. Suponha que comece à meia-noite, eu teria:

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 eu agendar com um atraso fixo de uma hora, eu teria:

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

Qual você deseja depende da sua tarefa.

Visualize séries temporais do scheduleAtFixedRatemétodo de invocação . As próximas execuções começarão imediatamente se a última demorar mais do que o período. Caso contrário, ele começará após o período.

Séries temporais do scheduleWithFixedDelaymétodo de invocação . A próxima execução começará após o tempo de atraso entre o término de uma execução e o início da próxima, independentemente do seu tempo de execução

Espero poder te ajudar

O scheduleAtFixedRate()método cria uma nova tarefa e a envia ao executor a cada período, independentemente de a tarefa anterior ter sido concluída ou não .

Por outro lado, o scheduleWithFixedDelay()método cria uma nova tarefa após o término da tarefa anterior .

Se você ler o Java Doc, será mais claro

ScheduledFuture scheduleAtFixedRate (comando Runnable, long initialDelay, longo período, unidade TimeUnit) Cria e executa uma ação periódica que é habilitada primeiro após o atraso inicial fornecido e, subsequentemente, com o período determinado; isto é, as execuções começarão após initialDelay, initialDelay + período, initialDelay + 2 * período e assim por diante.

ScheduledFuture scheduleWithFixedDelay (comando Runnable, long initialDelay, long delay, unidade TimeUnit) Cria e executa uma ação periódica que se torna habilitada primeiro após o determinado atraso inicial e, subsequentemente, com o determinado atraso entre o término de uma execução e o início da próxima.

Existe um problema em scheduleAtFixedRate se o primeiro thread está demorando muito e não terminou com a duração dada então o segundo thread consciencial não iniciará uma vez que a primeira tarefa será concluída e não será iniciada imediatamente enquanto o primeiro thread terminar sua tarefa e receber a duração foi decorrido. JVM decidirá quando a próxima tarefa será executada.

Acho que vai te ajudar a escolher o método Porque devido a isso eu tenho um grande problema

Vamos escrever um programa simples:

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 veja os 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 o tempo de execução é maior do que a espera

scheduleWithFixedDelay mantém atraso
scheduleAtFixedRate remove atraso

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

Basta executá-lo e você saberá a diferença. Obrigado