java - ¿Cómo atrapar apropiadamente las Excepciones de tiempo de ejecución de los ejecutores?

concurrency executor

Question

Digamos que tengo el siguiente código:

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(myRunnable);

Ahora, si myRunnable arroja RuntimeExcpetion , ¿cómo puedo atraparlo? Una forma sería suministrar mi propia implementación de newSingleThreadExecutor() a newSingleThreadExecutor() y establecer custom uncaughtExceptionHandler para los Thread s que newSingleThreadExecutor() de ella. Otra forma sería ajustar myRunnable a un myRunnable local (anónimo) que contenga un try-catch -block. Tal vez hay otras soluciones similares también. Pero ... de alguna manera esto se siente sucio, siento que no debería ser tan complicado. ¿Hay una solución limpia?

Answer 1

¿Por qué no llamar a ExecutorService#submit() , recuperar el Future y manejar las posibles excepciones usted mismo al llamar a Future#get() ?

Answer 2

Decora el ejecutable en otro ejecutable que capta las excepciones de tiempo de ejecución y las maneja:

public class REHandler implements Runnable {
    Runnable delegate;
    public REHandler (Runnable delegate) {
        this.delegate = delegate;
    }
    public void run () {
        try {
            delegate.run ();
        } catch (RuntimeException e) {
            ... your fancy error handling here ...
        }
    }
}

executor.execute(new REHandler (myRunnable));

Answer 3

La solución alternativa es utilizar ExecutorService.submit() lugar de execute() . Esto le devuelve un Future que puede usar para recuperar el resultado o la excepción de la tarea:

ExecutorService executor = Executors.newSingleThreadExecutor();
Runnable task = new Runnable() {
  public void run() {
    throw new RuntimeException("foo");
  }
};

Future<?> future = executor.submit(task);
try {
  future.get();
} catch (ExecutionException e) {
  Exception rootException = e.getCause();
}

Answer 4

skaffman tiene razón en que usar submit es el enfoque más limpio. Un enfoque alternativo es subclase ThreadPoolExecutor y anular afterExecute(Runnable, Throwable) . Si sigue este enfoque, asegúrese de llamar a execute(Runnable) lugar de submit(Runnable) o afterExecute no se invocará.

Por la descripción de la API:

Método invocado al finalizar la ejecución del Runnable dado. Este método es invocado por el hilo que ejecutó la tarea. Si no es nulo, el Throwable es el RuntimeException o Error RuntimeException que provocó que la ejecución finalizara abruptamente.

Nota: Cuando las acciones se envuelven en tareas (como FutureTask) de forma explícita o mediante métodos como enviar, estos objetos de tareas capturan y mantienen excepciones computacionales, por lo que no causan una terminación abrupta, y las excepciones internas no se pasan a este método .

Answer 5

una tarea ( Callable o Runnable ) enviada a ThreadPoolExecutors se convertirá en una FuturnTask , que contiene una propiedad llamada callable igual a la tarea que envía. FuturnTask tiene su propio método de run siguiente manera. Toda excepción o c.call() en c.call() será atrapado y puesto en un outcome llamado prop. Al llamar al método de obtención de FuturnTask, se arrojará el outcome

FuturnTask.run del código fuente Jdk1.8

public void run() {
        ...
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    // save ex into `outcome` prop
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        }
        ...
    }

si quieres ver la excepción:

1. La respuesta de skaffman

2. sobrescribe `afterExecute` cuando usted nuevo un ThreadPoolExecutor

        @Override
        protected void afterExecute(Runnable r, Throwable t) {
            super.afterExecute(r, t);
            Throwable cause = null;
            if (t == null && r instanceof Future) {
                try {
                    ((Future<?>) r).get();
                } catch (InterruptedException | ExecutionException e) {
                    cause = e;
                }
            } else if (t != null) {
                cause = t;
            }
            if (cause != null) {
                // log error
            }
        }