JAVA CompletableFuture异常传播不生效问题原因与最佳实践 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

JAVA CompletableFuture 异常传播不生效问题原因与最佳实践

大家好，今天我们来聊聊 Java CompletableFuture 中一个比较常见但又容易被忽略的问题：异常传播不生效。CompletableFuture 作为异步编程的利器，在处理并发任务时能够显著提升性能和响应速度。然而，如果对它的异常处理机制理解不够透彻，就容易遇到异常没有正确传播，导致程序出现难以调试的错误。

一、CompletableFuture 异常传播机制概述

CompletableFuture 的核心思想是将异步操作封装成一个 Future 对象，并通过一系列的组合操作（如 thenApply, thenAccept, thenCompose, exceptionally, handle, whenComplete 等）来定义任务的依赖关系和处理结果。异常传播是这些组合操作中至关重要的一个环节。

理想情况下，如果 CompletableFuture 链中的某个阶段发生异常，这个异常应该能够沿着链条传递，直到被显式地处理或者最终导致程序终止。然而，实际情况并非总是如此。下面我们来分析一下导致异常传播失效的常见原因。

二、异常传播失效的常见原因

忽略异常处理方法:

这是最常见的原因。如果我们没有使用任何异常处理方法（例如 exceptionally, handle, whenComplete），那么未捕获的异常会被 CompletableFuture 吞噬，导致程序无法感知到错误。
```
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   if (true) {
       throw new RuntimeException("模拟异常");
   }
   return "成功";
});

// 没有异常处理，异常会被吞噬
future.thenAccept(result -> System.out.println("结果: " + result));

// 主线程不会感知到异常，程序继续执行
System.out.println("程序继续执行...");
Thread.sleep(2000); // 确保异步任务完成
```
在这个例子中，RuntimeException 被抛出，但是由于没有使用 exceptionally、handle 或 whenComplete 等方法来捕获它，所以主线程无法感知到异常，程序会继续执行。

错误地使用 exceptionally:

exceptionally 方法用于处理异常，并返回一个备用值。但是，如果 exceptionally 内部也抛出了异常，并且没有再次处理，那么这个异常也会被吞噬。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   if (true) {
       throw new RuntimeException("模拟异常");
   }
   return "成功";
});

CompletableFuture<String> recoveredFuture = future.exceptionally(ex -> {
   System.err.println("捕获到异常: " + ex.getMessage());
   // 错误示范：exceptionally 中再次抛出异常，未处理
   throw new IllegalStateException("处理异常时也出错了", ex);
   //return "备用值"; // 正确示范：返回备用值，不抛出异常
});

recoveredFuture.thenAccept(result -> System.out.println("结果: " + result));
System.out.println("程序继续执行...");
Thread.sleep(2000);

在这个例子中，exceptionally 捕获了 RuntimeException，但是又抛出了 IllegalStateException。如果没有进一步处理这个 IllegalStateException，它也会被 CompletableFuture 吞噬。

使用 thenApply, thenAccept 等方法时，内部抛出受检异常:

thenApply, thenAccept 等方法只能处理返回值的转换和消费，不能直接处理受检异常（Checked Exception）。如果在这些方法内部抛出受检异常，需要将其包装成非受检异常（Unchecked Exception），否则编译报错。如果包装不当，也可能导致异常被忽略。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "成功");

// 错误示范：thenApply 中抛出受检异常，编译报错
// CompletableFuture<Integer> transformedFuture = future.thenApply(result -> {
//     throw new IOException("模拟受检异常"); // 编译错误
//     //return result.length();
// });

// 正确示范：将受检异常包装成非受检异常
CompletableFuture<Integer> transformedFuture = future.thenApply(result -> {
   try {
       throw new IOException("模拟受检异常");
   } catch (IOException e) {
       throw new RuntimeException(e); // 包装成非受检异常
   }
   //return result.length();
});

transformedFuture.exceptionally(ex -> {
   System.err.println("捕获到异常: " + ex.getMessage());
   return -1;
}).thenAccept(len -> System.out.println("长度: " + len));

System.out.println("程序继续执行...");
Thread.sleep(2000);

在这个例子中，直接在 thenApply 中抛出 IOException 会导致编译错误。需要将其包装成 RuntimeException 或其他非受检异常。

错误的组合操作:

某些组合操作，例如 allOf 和 anyOf，对于异常的处理方式需要特别注意。allOf 会等待所有 CompletableFuture 完成，如果其中任何一个抛出异常，异常会被聚合，需要显式处理。anyOf 只要有一个 CompletableFuture 完成，就会返回结果，如果第一个完成的 CompletableFuture 抛出异常，这个异常会被传播。

CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
   if (true) {
       throw new RuntimeException("future1 异常");
   }
   return "future1";
});

CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "future2");

// 使用 allOf
CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);

allOfFuture.exceptionally(ex -> {
   System.err.println("allOf 捕获到异常: " + ex.getMessage());
   return null; // 需要返回 null，因为 allOf 的结果是 Void
}).thenRun(() -> {
   System.out.println("allOf 完成");
});

// 使用 anyOf
CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2);

anyOfFuture.thenAccept(result -> {
   System.out.println("anyOf 结果: " + result);
}).exceptionally(ex -> {
   System.err.println("anyOf 捕获到异常: " + ex.getMessage());
   return null; // 需要返回 null，因为 allOf 的结果是 Void
});

System.out.println("程序继续执行...");
Thread.sleep(2000);

在这个例子中，allOf 需要使用 exceptionally 来捕获所有 future 中抛出的异常。anyOf 只要 future1 抛出异常，这个异常就会被传播到 anyOfFuture 上。

使用自定义 Executor 时，Executor 处理异常不当:

如果 CompletableFuture 使用了自定义的 Executor，那么需要确保 Executor 能够正确处理异常。例如，如果 Executor 使用了线程池，并且线程池的 uncaught exception handler 没有正确配置，那么异常可能会被线程池吞噬。

ExecutorService executor = Executors.newFixedThreadPool(2);

Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
   System.err.println("线程 " + thread.getName() + " 发生未捕获异常: " + throwable.getMessage());
});

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   if (true) {
       throw new RuntimeException("Executor 模拟异常");
   }
   return "成功";
}, executor);

future.thenAccept(result -> System.out.println("结果: " + result))
       .exceptionally(ex -> {
           System.err.println("捕获到异常: " + ex.getMessage());
           return null;
       });

System.out.println("程序继续执行...");
Thread.sleep(2000);
executor.shutdown();

在这个例子中，我们设置了全局的 UncaughtExceptionHandler，以便捕获线程池中未捕获的异常。

三、CompletableFuture 异常处理的最佳实践

始终显式地处理异常:

不要忽略任何可能抛出异常的 CompletableFuture。使用 exceptionally、handle 或 whenComplete 等方法来显式地处理异常。

选择合适的异常处理方法:

exceptionally(Function<Throwable, ? extends T> fn): 用于提供一个备用值，如果 CompletableFuture 抛出异常，则返回备用值。适用于需要从异常中恢复的场景。
handle(BiFunction<? super T, Throwable, ? extends U> fn): 用于同时处理正常结果和异常情况。可以根据结果或异常来返回不同的值。适用于需要根据结果或异常执行不同逻辑的场景。
whenComplete(BiConsumer<? super T, ? super Throwable> action): 用于在 CompletableFuture 完成时执行一个动作，无论是否发生异常。适用于需要进行清理操作或日志记录的场景。

方法	功能描述	适用场景
exceptionally	如果 CompletableFuture 抛出异常，则使用提供的函数计算备用值。	从异常中恢复，提供默认值或备用方案。
handle	无论 CompletableFuture 是正常完成还是抛出异常，都使用提供的函数处理结果或异常。该函数可以返回一个新值，该值将成为新的 CompletableFuture 的结果。	需要同时处理正常结果和异常情况，根据不同情况进行不同的处理。
whenComplete	无论 CompletableFuture 是正常完成还是抛出异常，都执行提供的操作。该操作不会修改 CompletableFuture 的结果。	在 CompletableFuture 完成后执行清理操作，例如关闭资源，记录日志等。

避免在异常处理方法中再次抛出异常:

如果在 exceptionally 或 handle 方法中再次抛出异常，确保这个异常也被处理，否则它会被吞噬。如果需要抛出异常，可以考虑使用 CompletableFuture.failedFuture(Throwable) 来创建一个失败的 CompletableFuture。
正确处理受检异常:

在 thenApply, thenAccept 等方法中，如果需要处理受检异常，将其包装成非受检异常。
理解组合操作的异常处理方式:

在使用 allOf 和 anyOf 等组合操作时，仔细阅读 API 文档，了解它们的异常处理方式，并进行相应的处理。
配置自定义 Executor 的异常处理:

如果使用了自定义的 Executor，确保 Executor 能够正确处理异常，例如配置线程池的 uncaught exception handler。

使用日志记录:

在异常处理方法中，使用日志记录来记录异常信息，方便调试和排查问题。

private static final Logger logger = Logger.getLogger(CompletableFutureDemo.class.getName());

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
   if (true) {
       logger.log(Level.SEVERE, "模拟异常");
       throw new RuntimeException("模拟异常");
   }
   return "成功";
});

future.exceptionally(ex -> {
   logger.log(Level.SEVERE, "捕获到异常: " + ex.getMessage(), ex);
   return "备用值";
}).thenAccept(result -> logger.log(Level.INFO, "结果: " + result));

四、代码示例：一个完整的异常处理示例

import java.io.IOException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class CompletableFutureDemo {

    private static final Logger logger = Logger.getLogger(CompletableFutureDemo.class.getName());

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // 设置全局的 UncaughtExceptionHandler
        Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
            logger.log(Level.SEVERE, "线程 " + thread.getName() + " 发生未捕获异常: " + throwable.getMessage(), throwable);
        });

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            if (true) {
                logger.log(Level.SEVERE, "supplyAsync 模拟异常");
                throw new RuntimeException("模拟异常");
            }
            return "成功";
        }, executor).thenApply(result -> {
            try {
                // 模拟受检异常
                throw new IOException("模拟受检异常");
            } catch (IOException e) {
                logger.log(Level.SEVERE, "thenApply 捕获受检异常", e);
                throw new RuntimeException(e); // 包装成非受检异常
            }
            //return result.length();
        }).exceptionally(ex -> {
            logger.log(Level.SEVERE, "exceptionally 捕获到异常: " + ex.getMessage(), ex);
            return "备用值";
        }).whenComplete((result, ex) -> {
            if (ex != null) {
                logger.log(Level.SEVERE, "whenComplete 捕获到异常: " + ex.getMessage(), ex);
            } else {
                logger.log(Level.INFO, "结果: " + result);
            }
        });

        future.thenAccept(result -> logger.log(Level.INFO, "最终结果: " + result));

        System.out.println("程序继续执行...");
        Thread.sleep(2000);
        executor.shutdown();
    }
}

这个例子展示了如何使用 exceptionally、handle 和 whenComplete 来处理 CompletableFuture 链中的异常，以及如何处理受检异常和配置自定义 Executor 的异常处理。

五、总结：重视异常处理，确保程序健壮性

CompletableFuture 的异常传播机制虽然强大，但也容易被误用。理解其工作原理，并遵循最佳实践，可以有效地避免异常被吞噬，确保程序的健壮性和可靠性。务必始终显式地处理异常，选择合适的异常处理方法，并避免在异常处理方法中再次抛出未处理的异常。正确处理受检异常、理解组合操作的异常处理方式、配置自定义 Executor 的异常处理，以及使用日志记录，都是保障 CompletableFuture 异常处理正确性的关键。

JAVA CompletableFuture 异常传播不生效问题原因与最佳实践

发表回复 取消回复

发表回复取消回复