Как правильно отловить RuntimeExceptions от исполнителей?

Чистый обходной путь - использовать ExecutorService.submit() вместо execute(). Это вернет вам Future, который вы можете использовать для получения результата или исключения задачи:

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();
}

Украсьте runnable в другом runnable, который улавливает исключения времени выполнения и обрабатывает их:

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));

Почему бы не вызвать _ 1_, получите Future назад, а затем самостоятельно обрабатывать возможные исключения при вызове _ 3_?

Скаффман прав в том, что использование submit - самый чистый подход. Альтернативный подход - создать подкласс ThreadPoolExecutor и переопределить afterExecute(Runnable, Throwable). Если вы последуете этому подходу, обязательно вызовите execute(Runnable), а не submit(Runnable), иначе afterExecute не будет вызван.

Согласно описанию API:

Метод, вызываемый после завершения выполнения данного Runnable. Этот метод вызывается потоком, выполнившим задачу. Если не равно нулю, Throwable - это неперехваченные RuntimeException или Error, которые привели к внезапному прекращению выполнения.

Примечание. Когда действия заключены в задачи (например, FutureTask) явно или с помощью таких методов, как submit, эти объекты задач улавливают и поддерживают вычислительные исключения, поэтому они не вызывают внезапного завершения, а внутренние исключения не передаются. к этому методу.

задача (Callable или Runnable), отправленная в ThreadPoolExecutors, будет преобразована в FuturnTask, содержит свойство с именем callable, равное отправляемой вами задаче. FuturnTask имеет свой собственный run метод, как показано ниже. Все исключения или бросаемые в c.call() исключения будут перехвачены и помещены в свойство с именем outcome. При вызове метода get FuturnTask будет выброшено outcome

FuturnTask.run из исходного кода 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);
            }
        }
        ...
    }

если вы хотите поймать исключение:

1. skaffman's answer
2. overwrite `afterExecute` when you new a 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
            }
        }