Wie neu zu starten, zu planen, Wann scheduleWithFixedDelay eine exception wirft?

Benutze ich ScheduledExecutorService planen einige Aufgaben, die brauchen, um ausführen regelmäßig.
Ich möchte wissen, ob dieser code funktioniert nach Wiederherstellung der Zeitplan, wenn eine Ausnahme passiert.

ScheduledExecutorService service = Executors.newScheduledThreadPool(1);
this.startMemoryUpdateSchedule(service);//See below method

//Recursive method to handle exception when run schedule task
private void startMemoryUpdateSchedule(ScheduledExecutorService service) {
    ScheduledFuture<?> future = service.scheduleWithFixedDelay(new MemoryUpdateThread(), 1, UPDATE_MEMORY_SCHEDULE, TimeUnit.MINUTES);
    try {
        future.get();
    } catch (ExecutionException e) {
        e.printStackTrace();
        logger.error("Exception thrown for thread",e);
        future.cancel(true);
        this.startMemoryUpdateSchedule(service);
    } catch(Exception e) {
        logger.error("Other exception ",e);
    }
}
  • hey, wenn Sie diesen Aufruf.startMemoryUpdateSchedule(service) aus dem Haupt-thread. Der Haupt-thread muss warten, bis Prozess zu beenden, aber Ihre Funktion wird ausgeführt foreover.der Haupt-thread gehen, um zu schlafen??
  • Parannoy, ich erstelle ein neuen thread für diese Funktion aus dem Haupt-thread.
InformationsquelleAutor Simon Wang | 2012-05-30
  1. 1

    Sollten Sie wahrscheinlich schließen Sie den try-block in einem while(true) - Schleife, denn wenn der erste run nicht eine Ausnahme werfen, verlassen Sie Ihre Methode, und wenn Sie den zweiten Anruf wirft man Sie nicht fangen.

    Ich würde auch den rekursiven Aufruf in einem eigenen thread, um das Risiko zu vermeiden, einen StackOverFlow Fehler, wenn Dinge schlecht gehen.

    Also würde es so Aussehen:

    private void startMemoryUpdateSchedule(final ScheduledExecutorService service) {
    final ScheduledFuture<?> future = service.scheduleWithFixedDelay(new MemoryUpdateThread(), 1, UPDATE_MEMORY_SCHEDULE, TimeUnit.MINUTES);
    Runnable watchdog = new Runnable() {

        @Override
        public void run() {
            while (true) {
                try {
                    future.get();
                } catch (ExecutionException e) {
                    //handle it
                    startMemoryUpdateSchedule(service);
                    return;
                } catch (InterruptedException e) {
                    //handle it
                    return;
                }
            }
        }
    };
    new Thread(watchdog).start();
}
    • assylias, ich nenne startMemoryUpdateSchedule () - Methode in der init() eines Servlets, es scheint, es wird geblockt, selbst wenn keine Ausnahme geworfen wird?
    • Nicht sicher, ob ich Ihre Frage verstehe. Den code ich schlug sofort zurück, weil die blockierenden Aufruf (future.get()) wird von einem separaten thread. Ich denke, am Ende muss man einige tests mit einem einfachen Thread, der sendet eine Ausnahme alle 5 fordert zum Beispiel, und sehen, ob das Verhalten wie erwartet.
    • assylias, vielen Dank für deine Erklärung, ich denke, es ist mir klar, jetzt~
    InformationsquelleAutor assylias
  2. 1

    Versuchen, VerboseRunnable Klasse aus jcabi-log, die entworfen ist, für genau diesen Zweck:

    import com.jcabi.log.VerboseRunnable;
Runnable runnable = new VerboseRunnable(
  Runnable() {
    public void run() { 
      //do business logic, may Exception occurs
    }
  },
  true //it means that all exceptions will be swallowed and logged
);

    Nun, wenn jemand ruft runnable.run() keine Ausnahmen geworfen werden. Stattdessen werden Sie geschluckt und protokolliert (zu SLF4J).

    • Scheint toll~vielen Dank für deine info.
    • Du bist willkommen, aber Bedenken Sie, dass der beste Weg zu sagen "danke" ist zu upvote eine Antwort 🙂
    • Sorrt zu vergessen:)
    InformationsquelleAutor yegor256
  3. 0

    Habe ich die Schleife wie besprochen.

    public void startMemoryUpdateSchedule(final ScheduledExecutorService service) {

    boolean retry = false;

    do {

        ScheduledFuture<?> future = null;
        try {
            retry = false;
            future = service.scheduleWithFixedDelay(new MemoryUpdateThread(), 1, UPDATE_MEMORY_SCHEDULE, TimeUnit.SECONDS);
            future.get();
        } catch (ExecutionException e) {
            //handle
            future.cancel(true);
            retry = true;
        } catch(Exception e) {
            //handle
        }           

    } while (retry);

}
    • Wenn eine Ausnahme ausgelöst wird, die durch die zweite Ausführung, die Sie nicht fangen die Ausnahme, weil Sie würde haben beendet die Methode, nach der ersten (erfolgreichen) ausführen.
    InformationsquelleAutor Kalyan Sarkar
  4. 0

    ScheduledExecutorService.scheduleWithFixedDelay(Runnable, long, long, TimeUnit) wirft RejectedExecutionException (ein Kind von RuntimeException) ==> Wir können es fangen & retry Vorlage einmal mehr.

    Nun als future.get() soll das Ergebnis einer Ausführung, die wir brauchen, um es aufzurufen in einer Schleife.

    Auch der Ausfall einer Ausführung nicht auf das nächste geplante Ausführung, das unterscheidet den ScheduledExecutorService aus dem TimerTask, das führt die geplanten Aufgaben im selben thread => Fehler in einer Ausführung würde zum Abbruch der Zeitplan im Falle von TimerTask (http://stackoverflow.com/questions/409932/java-timer-vs-executorservice)
    Wir brauchen nur alle zu fangen die drei Ausnahmen von der Zukunft.bekommen(), aber wir können nicht rethrow Sie, dann werden wir nicht in der Lage sein, um das Ergebnis der nachfolgenden Ausführungen.

    Den code könnte sein: 

    public void startMemoryUpdateSchedule(final ScheduledExecutorService service) {
final ScheduledFuture<?> future;
    try {
        future = service.scheduleWithFixedDelay(new MemoryUpdateThread(),
                1, UPDATE_MEMORY_SCHEDULE, TimeUnit.SECONDS);
    } catch (RejectedExecutionException ree) {
        startMemoryUpdateSchedule(service);
        return;
    }
    while (true) {
        try {
            future.get();
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
        } catch (ExecutionException ee) {
            Throwable cause = ee.getCause();
            //take action, log etc.
        } catch (CancellationException e) {
          //safety measure if task was cancelled by some external agent.
        }
    }
}
    • Ich bin mir nicht sicher über das "scheitern einer Ausführung nicht auf das nächste geplante Ausführung" für scheduleWithFixedDelay. Von der Javadoc: Wenn jede Ausführung der Aufgabe trifft auf eine Ausnahme, die von den nachfolgenden Ausführungen, werden unterdrückt. Andernfalls wird die task nur dann beenden, über die Kündigung oder Beendigung des Vollziehers.
    InformationsquelleAutor lab bhattacharjee
Schreibe einen Kommentar