Attraper des exceptions de thread à partir de Java ExecutorService

Je ne crois pas qu'il existe une "norme" hook " pour arriver à ces exceptions lors de l'utilisation de submit(). Toutefois, si vous avez besoin de soutien submit() (ce qui semble raisonnable, étant donné que vous utilisez un Callable), vous pouvez toujours placer l'Callables et Runnables :

ExecutorService executor = new ThreadPoolExecutor(1, 10, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>()) {
    @Override
    public <T> Future<T> submit(final Callable<T> task) {
        Callable<T> wrappedTask = new Callable<T>() {
            @Override
            public T call() throws Exception {
                try {
                    return task.call();
                }
                catch (Exception e) {
                    System.out.println("Oh boy, something broke!");
                    e.printStackTrace();
                    throw e;
                }
            }
        };

        return super.submit(wrappedTask);
    }
};

Bien sûr, cette méthode ne fonctionne que si vous êtes l'un des bâtiments de la ExecutorService en premier lieu. En outre, n'oubliez pas de remplacer tous les trois submit() variantes.

Comme expliqué dans ce fil Quelle est la différence entre présenter et exécuter la méthode avec ThreadPoolExecutorexécution ne fonctionnera que si vous mettez en œuvre Exécutables, et pas Exigible à la commande exécuter ne peut pas renvoyer un Avenir.

Je pense que dans votre cas, vous devez construire le futur de l'objet de sorte qu'il peut accueillir l'exception de trucs aussi. Ainsi, en cas d'exception vous de construire le message d'erreur de l'objet.

Je n'ai pas eu beaucoup de chance avec les autres réponses, car j'avais besoin de l'exception de l'instance, lui-même, et pas seulement d'une impression de trace de la pile. Pour moi, la accepté de répondre impliquant ThreadPoolExecutor#afterExecute() de la question "Pourquoi est-UncaughtExceptionHandler pas appelé par ExecutorService?" travaillé.

Voir l'exemple de code suivant:

List<Runnable> tasks = new LinkedList<>();
for (int i = 0; i < numThreads; ++i) {
    Runnable task = new Runnable() {
        @Override
        public void run() {
            throw new RuntimeException();
        }
    };

    tasks.add(task);
}

Optional<Throwable> opEmpty = Optional.empty();
/*
 * Use AtomicReference as a means of capturing the first thrown exception, since a
 * spawned thread can't "throw" an exception to the parent thread.
 */
final AtomicReference<Optional<Throwable>> firstThrownException =
        new AtomicReference<>(opEmpty);

/*
 * Use new ThreadPoolExecutor instead of Executors.newFixedThreadPool() so
 * that I can override afterExecute() for the purposes of throwing an
 * exception from the test thread if a child thread fails.
 */
ExecutorService execSvc = new ThreadPoolExecutor(numThreads, numThreads,
            0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()) {
    @Override
    public void afterExecute(Runnable task, Throwable failureCause) {
        if(failureCause == null) {
            //The Runnable completed successfully.
            return;
        }
        //only sets the first exception because it will only be empty on the first call.
        firstThrownException.compareAndSet(Optional.<Throwable>empty(), Optional.of(failureCause));
    }
};

for (Runnable task : tasks) {
    execSvc.execute(task);
}
execSvc.shutdown();
execSvc.awaitTermination(1, TimeUnit.HOURS);

assertEquals(firstThrownException.get(), Optional.empty());