处理ExecutionException的最佳方法是什么？

Question

我有一个方法可以执行一些超时任务。我使用ExecutorServer.submit（）获取Future对象，然后使用超时调用future.get（）。这工作正常，但是我的问题是处理可能由我的任务引发的检查异常的最佳方法。以下代码可以正常工作，并保留检查的异常，但是如果方法签名中的检查的异常列表发生更改，则显得非常笨拙且容易中断。

对于如何解决这个问题，有任何的建议吗？我需要以Java 5为目标，但我也想知道在Java的较新版本中是否有好的解决方案。

public static byte[] doSomethingWithTimeout( int timeout ) throws ProcessExecutionException, InterruptedException, IOException, TimeoutException {

    Callable<byte[]> callable = new Callable<byte[]>() {
        public byte[] call() throws IOException, InterruptedException, ProcessExecutionException {
            //Do some work that could throw one of these exceptions
            return null;
        }
    };

    try {
        ExecutorService service = Executors.newSingleThreadExecutor();
        try {
            Future<byte[]> future = service.submit( callable );
            return future.get( timeout, TimeUnit.MILLISECONDS );
        } finally {
            service.shutdown();
        }
    } catch( Throwable t ) { //Exception handling of nested exceptions is painfully clumsy in Java
        if( t instanceof ExecutionException ) {
            t = t.getCause();
        }
        if( t instanceof ProcessExecutionException ) {
            throw (ProcessExecutionException)t;
        } else if( t instanceof InterruptedException ) {
            throw (InterruptedException)t;
        } else if( t instanceof IOException ) {
            throw (IOException)t;
        } else if( t instanceof TimeoutException ) {
            throw (TimeoutException)t;
        } else if( t instanceof Error ) {
            throw (Error)t;
        } else if( t instanceof RuntimeException) {
            throw (RuntimeException)t;
        } else {
            throw new RuntimeException( t );
        }
    }
}

===更新===

许多人发布的响应建议要么1）作为一般例外重新抛出，或者2）作为未经检查的例外重新抛出。我不想做任何一个，因为这些异常类型（ProcessExecutionException，InterruptedException，IOException，TimeoutException）很重要-
所处理的调用将分别处理它们。如果我不需要超时功能，那么我希望我的方法抛出这4种特定的异常类型（好吧，除了TimeoutException）。我认为添加超时功能不应更改我的方法签名以抛出通用的Exception类型。

Answer 1

我已经深入研究了这个问题，很混乱。在Java
5、6或7中没有简单的答案。除了您指出的笨拙，冗长和脆弱之外，您的解决方案实际上还存在一个问题，ExecutionException即您在调用时要剥离的代码getCause()实际上包含了大多数内容。重要的堆栈跟踪信息！

也就是说，在您提供的代码中执行该方法的线程的所有堆栈信息仅在ExcecutionException中，而不在嵌套原因中，而嵌套原因仅覆盖call()Callable中的帧。也就是说，您的doSomethingWithTimeout方法甚至不会出现在您抛出的异常的堆栈跟踪中！您只会从执行程序中获得无实体的堆栈。这是因为ExecutionException是唯一在调用线程上创建的（请参阅FutureTask.get()）。

我知道的唯一解决方案很复杂。很多问题起源与自由派异常规范的Callable- throws Exception。您可以定义新的变体，Callable其中的新变体可以精确地指定它们引发的异常，例如：

public interface Callable1<T,X extends Exception> extends Callable<T> {

    @Override
    T call() throws X; 
}

这使执行可调用对象的方法具有更精确的throws子句。如果要支持最多N个异常的签名，很遗憾，您将需要此接口的N个变体。

现在，您可以围绕JDK编写包装，该包装Executor采用增强的Callable并返回增强的功能Future，例如番石榴的CheckedFuture。被检查的异常类型在编译时从的创建和类型传播ExecutorService到返回的Futures，并最终getChecked在将来使用该方法。

这就是您通过编译时类型安全性的方式。这意味着，而不是调用：

Future.get() throws InterruptedException, ExecutionException;

您可以致电：

CheckedFuture.getChecked() throws InterruptedException, ProcessExecutionException, IOException

因此避免了展开问题-您的方法立即引发所需类型的异常，并且这些异常在编译时可用并进行了检查。

在内部getChecked，但是您 仍然
需要解决上述“遗漏原因”展开问题。您可以通过将（调用线程的）当前堆栈缝合到引发的异常的堆栈上来实现此目的。这扩展了Java中堆栈跟踪的通常用法，因为单个堆栈跨线程扩展，但是一旦知道发生了什么，它就会起作用并且很容易理解。

另一种选择是创建 另一个
同样的事情作为一个被抛出的异常，并设定原为新的事业。您将获得完整的堆栈跟踪，并且原因关系将与它的工作方式相同ExecutionException-但您将拥有正确的异常类型。但是，您将需要使用反射，并且不能保证它能正常工作，例如，对于没有构造函数的具有常规参数的对象。