Erstellen eines Timers mit ScheduledExecutorService

Question

Also versuche ich herauszufinden, wie man einen Timer erstellt. Dabei bin ich auf Folgendes gestoßen: Verwendung von ScheduledExecutorService zum Starten und Stoppen des Timers

Das Beispiel, das sie haben, scheint ziemlich gut zu funktionieren. Ich frage mich nur, ob ich das richtig nutze:

public class TimerTest 
{
  private ScheduledExecutorService es = null;
  private boolean timeIsUp = false;
  private ScheduledFuture futureHandler = null;
  private TimeKeeper timeKeeper = null;
  private String subject = "";
  private int siteNo;
  private long time; 
  private boolean stop;

  public void endTimer()
  {
    System.out.println("Wir sollten hier alles herunterfahren");
    es.shutdownNow();
  }

  public boolean stopTimer()
  {
    if (timeKeeper != null)
    {
        timeKeeper.deactivate();
    }
    futureHandler.cancel(true);
    return true;
  }

  public boolean isTimeup()
  {
    return timeKeeper.isTimeUp();
  }

  public void startTimer(long mseconds, String subj, int sNo)
  {
    subject = subj;
    siteNo = sNo;
    time = mseconds;
    timeKeeper = new TimeKeeper();
    callScheduler(mseconds);
  }

  public boolean isTimerRunning()
  {
    return (es.isShutdown() || es == null);
  }

  public void resetTimer(long t)
  {
    stopTimer();
    callScheduler(t);
  }

  public void resetTimer()
  {
    resetTimer(time);  
  }

  private void callScheduler(long mseconds)
  {
    if (es == null)
        es = Executors.newScheduledThreadPool(3);
    timeKeeper = new TimeKeeper();
    futureHandler = es.schedule(timeKeeper, mseconds, TimeUnit.MILLISECONDS);
  }

  private class TimeKeeper implements Runnable  {
    private volatile boolean isActive = true;  
    private volatile boolean isTimeUp = false;

    public void run()   {  
        if (isActive){
            callAlert();
            isTimeUp = true;
        }
    }  

    public void deactivate(){
        isActive = false;
    }

    public boolean isTimeUp()
    {
        return isTimeUp;
    }

    private void callAlert()
    {
        System.out.println("Sie befinden sich in der Methode callAlert");
    }
  }
}

Und hier ist der Test:

public static void main(String[] args) {
    long pastTime = System.currentTimeMillis();
    TimerTest timer = new TimerTest();
    timer.startTimer(15000, "bh", 1);
    long time;
    int count =0;
    boolean stop = false;
    while(true)
    {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        time = System.currentTimeMillis() - pastTime;

        if (time > 3000)
        {
            if (!stop){
                System.out.println("Wir setzen den Timer zurück");
                timer.resetTimer(4000);
                timer.stopTimer();
                try {
                    Thread.sleep(3995);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                break;
            }
            stop = true;
        }
        if (timer.isTimeup())
        {
            System.out.println("Unsere Zeit ist abgelaufen");
            timer.endTimer();
            break;
        }
        if (!stop)
            System.out.println("Hallo");
        else
        {
            if (count == 0)
                System.out.println("Wir warten jetzt 10 Sekunden");
            count++;
        }
    }
    timer.resetTimer(1200);
    while (true)
    {
        if (timer.isTimeup())
        {
            timer.isTimeup();
            System.out.println("Nach Ablauf der Zeit brechen wir ab");
            break;
        }
    }
    timer.endTimer();
}

Dies scheint zu funktionieren, aber möglicherweise habe ich etwas übersehen, das noch benötigt wird. Das ist das erste Mal, dass ich mit ScheduledExecutorService arbeite. Sehen Sie irgendwelche Probleme mit diesem Code? Ich möchte keine Konflikte mit Thread-Kollisionen haben.

Answer 1

Mit ScheduledExecutorService erhalten Sie automatisch die Timer-Funktion. Sie brauchen sie nicht explizit, es sei denn, Sie haben etwas, das der ScheduleExecutorService nicht bereitstellen kann. z.B. Angenommen, Sie möchten eine Aufgabe nach einer anfänglichen Verzögerung von 10 Sekunden starten und dann anschließende Verzögerungen von jeweils 5 Sekunden.

public void init() {
    executor = new ScheduledThreadPoolExecutor(corePoolSize);
    executor.scheduleWithFixedDelay(new WorkerThread(), 10, 5, TimeUnit.SECONDS);
}

public void end() {
    executor.shutdown();
}