ScheduledExecutorService con ritardo variabile

Question

Supponiamo di avere un task che sta richiamando elementi da un java.util.concurrent.BlockingQueue ed elaborandoli.

public void scheduleTask(int delay, TimeUnit timeUnit) 
{ 
    scheduledExecutorService.scheduleWithFixedDelay(new Task(queue), 0, delay, timeUnit); 
} 

Come posso programmare/riprogrammare l'attività se la frequenza può essere modificata in modo dinamico?

• L'idea è quella di prendere un flusso di aggiornamenti dei dati e li propagano in batch per una GUI
• L'utente deve essere in grado di variare la frequenza degli aggiornamenti

Answer 1

Non penso che sia possibile modificare un ritardo di frequenza fissa. Penso che sia necessario utilizzare schedule() per eseguire uno scatto singolo e riprogrammare una volta completato (con un timeout modificato, se necessario).

Answer 2

Non dovresti utilizzare scheduleAtFixedRate se si sta tentando di elaborare diverse attività di coda con un intervallo specifico? scheduleWithFixedDelay attenderà solo il ritardo specificato e quindi eseguirà un'attività dalla coda.

In entrambi i casi, i metodi schedule* in un ScheduledExecutorService restituiscono un riferimento ScheduledFuture. Se si desidera modificare la tariffa, è possibile annullare ScheduledFuture e riprogrammare l'attività con una frequenza diversa.

Answer 3

scheduleWithFixedDelay (...) restituisce un RunnableScheduledFuture. Per riprogrammarlo, potresti semplicemente annullare e riprogrammare. Per ripianificare esso, si può solo avvolgere il RunnableScheduledFuture uno spirito nuovo Runnable:

new Runnable() { 
    public void run() { 
     ((RunnableScheduledFuture)future).run(); 
    } 
}; 

Answer 4

Usa schedule(Callable<V>, long, TimeUnit) piuttosto che scheduleAtFixedRate o scheduleWithFixedDelay. Quindi assicurati che il tuo Callable si aggiorni da solo o una nuova istanza di Callable in futuro. Per esempio:

// Create Callable instance to schedule. 
Callable<Void> c = new Callable<Void>() { 
    public Void call() { 
    try { 
    // Do work. 
    } finally { 
    // Reschedule in new Callable, typically with a delay based on the result 
    // of this Callable. In this example the Callable is stateless so we 
    // simply reschedule passing a reference to this. 
    service.schedule(this, 5000L, TimeUnit.MILLISECONDS); 
    } 
    return null; 
    } 
} 

service.schedule(c); 

Questo approccio evita la necessità di spegnere e ricreare il ScheduledExecutorService.