In attesa del completamento di un timer in Java

Question

Sto utilizzando java.util.Timer per pianificare un'attività periodica. A un certo punto, mi piacerebbe spegnerlo, e attendere che finisca.

Timer.cancel() impedirà l'esecuzione di attività future. Come posso assicurarmi che alcune attività non siano in esecuzione al momento (o aspettarle se lo sono?)

Posso introdurre meccanismi di sincronizzazione esterni, ma non vedo come possano coprire tutti i casi. Ad esempio, se eseguo la sincronizzazione su alcuni monitor all'interno dell'attività, mi manca ancora il caso quando l'attività ha appena iniziato ad essere eseguita ma non ha preso il monitor.

Qual è la pratica consigliata per l'attesa fino a quando tutte le attività vengono effettivamente eseguite, incluse le attività attualmente in esecuzione?

Answer 1

È preferibile utilizzare un ScheduledExecutorService anziché un timer per pianificare l'attività periodica. ScheduledExecutorService fornisce un metodo shutdown() che eseguirà tutte le attività in sospeso. È quindi possibile chiamare awaitTermination() per attendere la chiusura di shutdown().

Answer 2

Qualcosa di simile al di sotto potrebbe aiutare il vostro esigenze-

import java.util.Timer; 
import java.util.TimerTask; 

public class TimerGracefulShutdown { 
    public static void main(String[] args) throws InterruptedException { 
     //This is a synchronization helper class 
     SyncHelper syncHelper = new SyncHelper(); 

     TimerManager myTimerManager = new TimerManager(syncHelper); 

     //Try stopping timer after 5 seconds (it wont stop until the 30 seconds sleep of timertask does not finish) 
     Thread.currentThread().sleep(5000); 
     System.out.println("Going to stop my timer now"); 
     myTimerManager.stopTimer(); 
     System.out.println("Cancelled timer"); 
    } 
} 

class TimerManager { 

    SyncHelper syncHelper; 
    Timer timer; 

    public TimerManager(SyncHelper syncHelper) { 
     this.syncHelper = syncHelper; 
     startTimer(); 
    } 

    private void startTimer() { 
     timer = new Timer(true); 
     TimerTask myTask = new MyTimerTask(syncHelper); 
     timer.scheduleAtFixedRate(myTask, 0, 100000); 
    } 

    public void stopTimer() { 
     try { 
      syncHelper.testAndSetOrReset("acquire"); 
     } catch(Exception e) { 
      e.printStackTrace(); 
     } 

     //Shutdown the timer here since you know that your timertask is not executing right now. 
     timer.cancel(); 
     try { 
      syncHelper.testAndSetOrReset("release"); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

} 

class MyTimerTask extends TimerTask { 

    private SyncHelper syncHelper; 

    public MyTimerTask(SyncHelper syncHelper) { 
     this.syncHelper = syncHelper; 
    } 

    public void run() { 
     try { 
      syncHelper.testAndSetOrReset("acquire"); 
     } catch (Exception e1) { 
      e1.printStackTrace(); 
     } 

     System.out.println("Over here"); 
     try { 
      Thread.currentThread().sleep(30000); 
     } catch(Exception e) { 

     } 
     System.out.println("Done sleeping"); 

     //Finally release the helper. 
     try { 
      syncHelper.testAndSetOrReset("release"); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

} 

class SyncHelper { 

    private int index = 0; 

    public synchronized void testAndSetOrReset(String command) throws Exception { 

     if("acquire".equals(command)) { 
      if(index == 1) { 
       wait(); 
      } 
      index++; 
     } else if("release".equals(command)) { 
      index--; 
      notifyAll(); 
     } 
    } 
}