Gestione delle eccezioni in ThreadPools

Question

Ho un programma ScheduledThreadPoolExecutor che sembra mangiare eccezioni. Voglio che il mio servizio esecutore mi informi se un Runnable inviato genera un'eccezione.

Per esempio, mi piacerebbe il codice sottostante per lo meno di stampa del IndexArrayOutOfBoundsException stackTrace

threadPool.scheduleAtFixedRate(
    new Runnable() { 
    public void run() { 
     int[] array = new array[0]; 
     array[42] = 5; 
    } 
    }, 
    1000, 
    1500L, 
    TimeUnit.MILLISECONDS); 

Come una domanda lato. C'è un modo per scrivere un blocco catch try generale per ScheduledThreadPoolExecutor?

////////// FINE domanda iniziale //////////////

Come suggerito il seguente Decorator funziona bene.

public class CatcherTask implements Runnable{ 

    Runnable runMe; 

    public CatcherTask(Runnable runMe) { 
     this.runMe = runMe; 
    } 

    public void run() { 
     try { 
      runMe.run(); 
     } catch (Exception ex){ 
      ex.printStackTrace(); 
     } 
    } 
} 

Answer 1

Ho scritto un piccolo post su questo problema qualche tempo fa. Sono disponibili due opzioni:

1. utilizzare il solution fornito da Colin Herbert o
2. utilizzare una versione modificata di Mark Peters solution ma invece di assegnare un UncaughtExceptionHandler si avvolge presentato ciascuno eseguibile in un eseguibile della propria che esegue (chiama run) il vero eseguibile all'interno di un blocco try-catch.

EDIT
Come sottolineato da Mark, è importante per avvolgere il Runnable passati a ScheduledExecutorService invece di quello passato al ThreadFactory.

Answer 2

Warning: Questo metodo non è applicabile a linea esecutori pool di thread. Questa risposta non è stata eliminata per la sua rilevanza con altri esecutori di pool di thread. Vedi Willi's answer.

Override il ThreadFactory che invia un Discussioni UncaughtExceptionHandler:

ThreadPoolExecutor exec = new ThreadPoolExecutor...; 

exec.setThreadFactory(new ExceptionCatchingThreadFactory(exec.getThreadFactory())); 
//go on to submit tasks... 


private static class ExceptionCatchingThreadFactory implements ThreadFactory { 
    private final ThreadFactory delegate; 

    private ExceptionCatchingThreadFactory(ThreadFactory delegate) { 
     this.delegate = delegate; 
    } 

    public Thread newThread(final Runnable r) { 
     Thread t = delegate.newThread(r); 
     t.setUncaughtExceptionHandler(new UncaughtExceptionHandler() { 
      @Override 
      public void uncaughtException(Thread t, Throwable e) { 
       e.printStackTrace(); //replace with your handling logic. 
      } 
     }); 
     return t; 
    } 
} 

Answer 3

considerare l'aggiunta di un evento statico nella vostra ScheduledThreadPoolExecutor classe che le tue mansioni può chiamare se viene generata un'eccezione. In questo modo, puoi sfruttare quell'evento per acquisire e gestire le eccezioni che si verificano all'interno dei tuoi thread.

Answer 4

È possibile utilizzare il metodo get() dal numero Future che si ottiene chiamando scheduleAtFixedRate(). Lancia un ExecutionException se si verifica un errore durante l'esecuzione del thread.

Answer 5

È inoltre possibile utilizzare , che espone un metodo per impostare un gestore errori e fa tutto ciò che si desidera. Il comportamento predefinito dipende dal tipo di attività:

Se lo ErrorHandler fornito non è nullo, verrà utilizzato. In caso contrario, le attività ripetute avranno errori soppressi per impostazione predefinita mentre le attività one-shot avranno errori propagati per impostazione predefinita poiché tali errori potrebbero essere previsti tramite il valore restituito Future. In entrambi i casi, gli errori verranno registrati.

Se si desidera utilizzare solo la parte di avvolgimento e non il TaskScheduler è possibile utilizzare

TaskUtils.decorateTaskWithErrorHandler(task, errorHandler, isRepeatingTask) 

cui il TaskScheduler usa internamente.

Answer 6

È possibile creare sottoclasse ScheduledThreadPoolExecutor e sovrascrivere il metodo afterExecute per gestire eccezioni ed errori per qualsiasi tipo di Runnable inviato.