Reinitialize ritardo correzione in ScheduledExecutorService

Question

Come per la mia richiesta, devo eseguire del codice particolare dopo un certo periodo di tempo. Per fare lo stesso che ho scelto ScheduledExecutorService.scheduleWithFixedDelay(runnable, 0, 5, TimeUnit.SECONDS) e che sta funzionando bene per me. Ma secondo il mio un altro requisito, il termine indicato nella fixedDelay dovrebbe essere configurabile in fase di esecuzione. Mezzi, attualmente totale di ritardo è di 5 secondi, ma quest'ultimo se l'utente vuole poi può modificare il tempo in 60 secondi e in fase di esecuzione fixedDelay verrà eseguito dopo 60 secondi. Qualsiasi aiuto sarebbe apprezzabile.

Si prega di vedere il codice:

static int i = 0; 
    static ScheduledExecutorService executor; 
    static Runnable runnable; 
    static ScheduledFuture<?> future; 

    public static void main(String args[]) { 
     executor = Executors 
       .newScheduledThreadPool(1); 
     runnable = new Runnable() { 
      @Override 
      public void run() { 
       System.out.println("Inside runnable" + i++); 
       changeDelay(); 
      } 
     }; 
     future = 
       executor.scheduleWithFixedDelay(runnable, 0, 5, TimeUnit.SECONDS); 

    } 

    public static void changeDelay() { 
     future.cancel(false); 
     future = executor.scheduleWithFixedDelay(runnable, 0, 10, TimeUnit.SECONDS); 
    } 

Qui ho usato il metodo changeDelay per modificare il tempo di ritardo. Ma non sta funzionando.

Answer 1

è necessario mantenere il riferimento del ScheduledFuture<?> oggetto restituito:

ScheduledFuture<?> handle = 
     scheduler.scheduleWithFixedDelay(runnable, 0, 5, TimeUnit.SECONDS); 

Con questo riferimento si annulla l'attività corrente e creare un altro con il nuovo ritardo:

handle.cancel(false);  
handle = scheduler.scheduleWithFixedDelay(runnable, 0, 60, TimeUnit.SECONDS); 

Ecco un esempio:

public class Test5 { 
    static int i = 0; 
    static ScheduledExecutorService executor; 
    static Runnable runnable; 
    static ScheduledFuture<?> future; 

    public static void main(String args[]) throws InterruptedException{ 
     executor = Executors.newScheduledThreadPool(1); 
     runnable = new Runnable() { 
      @Override 
      public void run() { 
       System.out.println("Inside runnable" + i++); 
      } 
     }; 
     future = executor.scheduleWithFixedDelay(runnable, 0, 5, TimeUnit.SECONDS); 

     Thread.sleep(20000l); 

     changeDelay(); 
    } 

    public static void changeDelay() { 
     boolean res = future.cancel(false); 

     System.out.println("Previous task canceled: " + res); 

     future = executor.scheduleWithFixedDelay(runnable, 0, 20, TimeUnit.SECONDS); 
    } 
} 

Answer 2

come la vedo ScheduledExecutorService.scheduleWithFixedDelay(runnable, initDelay , delay, TimeUnit.SECONDS) rendimenti ScheduledFuture che non ha un metodo setDelay(delay), che le consentirà di cambiamento del ritardo una volta creato.

L'opzione migliore sarebbe quella di annullare la corrente eseguibile ScheduledFuture.cancel(false) e iniziare una nuova operazione pianificata con l'aiuto di scheduleWithFixedDelay usando nuovo valore di ritardo.

NON CHIAMAREchangeDelay dal metodo run. Invece chiamare da main metodo stesso come qui di seguito

import java.util.concurrent.Executors; 
import java.util.concurrent.ScheduledExecutorService; 
import java.util.concurrent.ScheduledFuture; 
import java.util.concurrent.TimeUnit; 

public class ScheduledExecutorExample { 
    static int i = 0; 
    static ScheduledExecutorService executor; 
    static Runnable runnable; 
    static ScheduledFuture<?> future; 

    public static void main(String args[]) { 
     executor = Executors.newScheduledThreadPool(1); 
     runnable = new Runnable() { 
      @Override 
      public void run() { 
       System.out.println("Inside runnable" + i++); 
      } 
     }; 
     future = executor.scheduleWithFixedDelay(runnable, 0, 2, TimeUnit.SECONDS); 
     try { 
      Thread.sleep(4000); //sleeping for 2 seconds 
     } catch (InterruptedException e) { 
      e.printStackTrace(); 
     } 
     changeDelay(); 
    } 

    public static void changeDelay() { 
     future.cancel(false); 
     future = executor.scheduleWithFixedDelay(runnable, 0, 10, TimeUnit.SECONDS); 
    } 
} 

Si vede che dopo un po 'le variazioni di ritardo a 10 secondi da 2 secondi