FutureCallback 中抛出异常处理方式

小咪咪 2024-03-17 23:15 101阅读 0赞

在Java中，`FutureCallback`是Guava库中的一个接口，用于处理`ListenableFuture`任务的回调。当使用`ListenableFuture`提交异步任务时，可以附加一个`FutureCallback`来处理任务执行完成后的结果或异常。

当在`FutureCallback`中抛出异常时，这取决于你在回调方法中的具体实现。Guava库本身不会捕获`FutureCallback`回调方法中的异常，也不会自动处理它们。所以，如果你在回调方法中抛出异常，它将会传播到调用者并中断继续执行。

例如，如果你有以下`FutureCallback`的实现：

FutureCallback<Result> callback = new FutureCallback<Result>() {
        
        @Override
        public void onSuccess(Result result) {
        
            // 处理任务成功的情况
        }
    
        @Override
        public void onFailure(Throwable t) {
        
            // 处理任务失败的情况
            throw new RuntimeException("Custom Exception");
        }
    };

在`onFailure`方法中抛出异常，这个异常会传播到调用者，并可能导致调用者的任务中断或异常处理逻辑执行。

如果你希望在`FutureCallback`中捕获异常并继续执行，你可以在`onFailure`方法内部进行异常处理，而不是将异常抛出。比如将异常记录日志，返回默认值，或者进行其他合适的处理。

请注意，`FutureCallback`的执行与`ListenableFuture`任务的执行是异步的，因此当抛出异常时，调用者的线程和`ListenableFuture`的执行线程是不同的。这也意味着`FutureCallback`的异常不会直接传播到`ListenableFuture`的执行线程，但仍然会影响到调用者的逻辑。

当在`FutureCallback`的回调方法中抛出异常时，异常将会传播到调用者的线程，可能导致调用者的任务中断或异常处理逻辑执行。下面是一个例子来说明这个情况：

import com.google.common.util.concurrent.*;
    
    import java.util.concurrent.Executors;
    
    public class ListenableFutureExample {
        
        public static void main(String[] args) {
        
            ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(5));
            ListenableFuture<Integer> future = executorService.submit(() -> {
        
                // 模拟在执行过程中抛出异常
                throw new RuntimeException("Exception in task");
            });
    
            FutureCallback<Integer> callback = new FutureCallback<Integer>() {
        
                @Override
                public void onSuccess(Integer result) {
        
                    // 这部分代码在任务完成后异步执行，不会中断主线程
                    System.out.println("Result: " + result);
                }
    
                @Override
                public void onFailure(Throwable t) {
        
                    // 这部分代码在任务执行过程中抛出异常后异步执行，不会中断主线程
                    System.err.println("Error occurred in callback: " + t.getMessage());
                    throw new RuntimeException("Exception in callback"); // 在回调中再次抛出异常
                }
            };
    
            Futures.addCallback(future, callback, executorService);
    
            try {
        
                // 等待任务完成
                future.get();
            } catch (Exception e) {
        
                // 在主线程捕获异常
                System.err.println("Caught exception in main thread: " + e.getMessage());
            }
    
            // 主线程继续执行
            System.out.println("Main thread continues.");
    
            // 关闭线程池
            executorService.shutdown();
        }
    }

在上面的例子中，我们提交了一个`ListenableFuture`任务，该任务在执行过程中故意抛出异常。然后，我们在`FutureCallback`的回调方法`onFailure()`中抛出另一个异常。这个异常不会影响`ListenableFuture`任务的执行线程，而是传播回调用者的线程，这里是`main`线程。因此，在主线程中会捕获到这个异常，并执行相应的异常处理逻辑。注意，`ListenableFuture`任务的执行线程并不会因为`FutureCallback`中的异常而受影响，任务的执行仍会继续。

这个例子展示了在使用`ListenableFuture`和`FutureCallback`时，如何处理异常以及异常的传播行为。请注意，异常处理逻辑需要根据实际情况进行适当的处理，确保程序的稳定性和正确性。