FutureCallback 中 抛出异常 处理方式

在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时，如何处理异常以及异常的传播行为。请注意，异常处理逻辑需要根据实际情况进行适当的处理，确保程序的稳定性和正确性。