处理Java ExecutorService任务中的异常 [英] Handling exceptions from Java ExecutorService tasks

问题描述

我正在尝试使用Java的 ThreadPoolExecutor 类来运行具有固定线程数的大量重量级任务。每个任务都有很多地方可能会因例外而失败。

I'm trying to use Java's ThreadPoolExecutor class to run a large number of heavy weight tasks with a fixed number of threads. Each of the tasks has many places during which it may fail due to exceptions.

我已经将 ThreadPoolExecutor 分组并且我已经覆盖了 afterExecute 方法，该方法应该提供运行任务时遇到的任何未捕获的异常。但是，我似乎无法使其发挥作用。

I've subclassed ThreadPoolExecutor and I've overridden the afterExecute method which is supposed to provide any uncaught exceptions encountered while running a task. However, I can't seem to make it work.

例如：

public class ThreadPoolErrors extends ThreadPoolExecutor {
    public ThreadPoolErrors() {
        super(  1, // core threads
                1, // max threads
                1, // timeout
                TimeUnit.MINUTES, // timeout units
                new LinkedBlockingQueue<Runnable>() // work queue
        );
    }

    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if(t != null) {
            System.out.println("Got an error: " + t);
        } else {
            System.out.println("Everything's fine--situation normal!");
        }
    }

    public static void main( String [] args) {
        ThreadPoolErrors threadPool = new ThreadPoolErrors();
        threadPool.submit( 
                new Runnable() {
                    public void run() {
                        throw new RuntimeException("Ouch! Got an error.");
                    }
                }
        );
        threadPool.shutdown();
    }
}

这个程序的输出是一切都很好 - 情况正常！即使提交给线程池的唯一Runnable引发异常。这里有什么线索？

The output from this program is "Everything's fine--situation normal!" even though the only Runnable submitted to the thread pool throws an exception. Any clue to what's going on here?

谢谢！

推荐答案

来自 docs ：

注意：当
任务（例如FutureTask）中的操作明确地或通过诸如$ b $之类的方法包含在
中b提交，这些任务对象捕获并且
维护计算异常，并且
因此它们不会导致突然的
终止，并且内部
异常不会传递给此
方法。

Note: When actions are enclosed in tasks (such as FutureTask) either explicitly or via methods such as submit, these task objects catch and maintain computational exceptions, and so they do not cause abrupt termination, and the internal exceptions are not passed to this method.

当你提交一个Runnable时，它将被包装在Future中。

When you submit a Runnable, it'll get wrapped in a Future.

你的afterExecute应该是这样的：

Your afterExecute should be something like this:

public final class ExtendedExecutor extends ThreadPoolExecutor {

    // ...

    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof Future<?>) {
            try {
                Future<?> future = (Future<?>) r;
                if (future.isDone()) {
                    future.get();
                }
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt();
            }
        }
        if (t != null) {
            System.out.println(t);
        }
    }
}

这篇关于处理Java ExecutorService任务中的异常的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！