当前位置：Java -> 掌握Java CompletableFuture中的异常处理：见解和示例

掌握Java CompletableFuture中的异常处理：见解和示例

Java CompletableFuture（CompletableFuture）是编写异步、非阻塞代码的多功能工具。尽管CompletableFuture简化了并发编程的许多方面，但理解如何有效处理异常是至关重要的。在本文中，我们将探讨CompletableFuture中的异常处理细节，并提供见解和真实世界的示例。

异常处理基础

异常处理在基于CompletableFuture的应用程序中至关重要，以优雅地处理在异步任务执行过程中可能发生的意外错误。CompletableFuture提供了多个方法来简化异常处理。

处理异常 exceptionally()

exceptionally()方法是在CompletableFuture中处理异常的首选方法。它允许您在CompletableFuture执行过程中出现异常时定义替代值或执行自定义逻辑。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Simulate an exception
    throw new RuntimeException("Something went wrong");
});

CompletableFuture<Integer> handledFuture = future.exceptionally(ex -> {
    System.err.println("Exception: " + ex.getMessage());
    return -1; // Provide a default value
});

handledFuture.thenAccept(result -> System.out.println("Result: " + result));


在此示例中，如果在future执行过程中发生异常，exceptionally()方法将通过打印错误消息并返回默认值-1来处理。然后将结果打印为"Result: -1"。

处理成功和失败 handle()

handle()方法是一种更全面的方法来处理异常。它允许您在单个回调中处理成功的结果和异常。此方法接受一个BiFunction来处理结果和异常（如果有）。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Simulate an exception
    throw new RuntimeException("Something went wrong");
});

CompletableFuture<String> handledFuture = future.handle((result, ex) -> {
    if (ex != null) {
        System.err.println("Exception: " + ex.getMessage());
        return "Default";
    } else {
        return "Result: " + result;
    }
});

handledFuture.thenAccept(result -> System.out.println(result));


在此示例中，handle()函数检查是否发生了异常（通过ex != null进行验证），并通过打印错误消息和提供默认值"Default"来作出响应。如果没有异常，则继续处理成功的结果，并提供与结果值一起的"Result: "。结果包括"Exception: Something went wrong"和"Default"。

CompletableFuture中的异常传播

理解异常在CompletableFuture链中如何传播至关重要。异常可以向下传播至链中，影响后续操作。以下是其工作原理。

thenApply()和类似方法中的异常传播：在thenApply()等操作中，如果源CompletableFuture发生异常，它会传播到依赖的CompletableFuture，导致跳过依赖操作。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Something went wrong");
});

CompletableFuture<String> handledFuture = future.thenApply(result -> "Result: " + result);

handledFuture.exceptionally(ex -> {
    System.err.println("Exception: " + ex.getMessage());
    return "Default";
});

// The exception propagates to handledFuture, skipping the transformation in thenApply.


exceptionally()或handle()中的异常处理：您可以使用exceptionally()或handle()拦截异常并进行处理。如果在这些方法中不处理异常，它将继续向下传播至链中。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Something went wrong");
});

CompletableFuture<Integer> handledFuture = future
    .exceptionally(ex -> {
        System.err.println("Exception: " + ex.getMessage());
        return -1;
    })
    .thenApply(result -> result * 2);

handledFuture.thenAccept(result -> System.out.println("Result: " + result));


在此示例中，exceptionally()方法处理异常，阻止它传播至后续的thenApply()操作。

结合CompletableFuture和异常处理

当将异常处理与CompletableFuture的组合多个异步任务的能力结合使用时，异常处理变得更加强大。在这里，我们将探讨如何在组合CompletableFuture实例时处理异常。

结合结果 thenCombine()

thenCombine()方法允许您组合两个CompletableFuture实例的结果。当源CompletableFuture中发生异常时，可以使用exceptionally()进行处理。

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Something went wrong in future1");
});

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 7);

CompletableFuture<Integer> combinedFuture = future1
        .exceptionally(ex -> {
            System.err.println("Exception in future1: " + ex.getMessage());
            return -1;
        })
        .thenCombine(future2, (result1, result2) -> result1 + result2);

combinedFuture.thenAccept(result -> System.out.println("Result: " + result));


在此示例中，future1抛出异常，但使用exceptionally()进行了优雅处理。对于future1，结果为-1，对于future2，结果为7，导致combinedFuture的最终结果为6。

异常处理和thenCompose()

thenCompose()方法用于顺序链接，还允许异常处理。在组合可能产生异常的CompletableFuture实例时特别有用。

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Something went wrong in future2");
});

CompletableFuture<Integer> combinedFuture = future1.thenCompose(result1 ->
    future2
        .exceptionally(ex -> {
            System.err.println("Exception in future2: " + ex.getMessage());
            return -1;
        })
        .thenApply(result2 -> result1 + result2));

combinedFuture.thenAccept(result -> System.out.println("Result: " + result));


在此示例中，future1成功完成，但future2抛出异常。对future2的异常进行了处理，并将结果与future1组合，生成combinedFuture的最终结果为4。

CompletableFuture中的超时处理

在现实世界的应用程序中，通常需要为异步操作设置超时，以防止它们无限期地阻塞。CompletableFuture提供了超时处理的机制。

提供默认值 completeOnTimeout()

completeOnTimeout()方法允许您指定在指定时间范围内未完成CompletableFuture时完成它的默认值。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Simulate a long-running operation
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 42;
});

CompletableFuture<Integer> withTimeout = future.completeOnTimeout(0, 2, TimeUnit.SECONDS);


在此示例中，如果future在2秒内未完成，它将完成为默认值0。

处理超时异常 orTimeout()

orTimeout()方法允许您为CompletableFuture设置最大时间限制。如果CompletableFuture在指定时间范围内未完成，则会抛出TimeoutException，您可以使用exceptionally()进行处理。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Simulate a long-running operation
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 42;
});

CompletableFuture<Integer> withTimeout = future.orTimeout(2, TimeUnit.SECONDS)
        .exceptionally(ex -> {
            System.err.println("Timeout occurred: " + ex.getMessage());
            return -1; // Handle the timeout gracefully
        });


在此示例中，如果future在2秒内未完成，将会抛出TimeoutException，并通过exceptionally()进行处理，提供默认值-1。

自定义异常处理

在CompletableFuture中自定义异常处理允许您根据应用程序的要求定义特定的错误处理逻辑。这可以包括日志记录、重试或采取其他纠正措施。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // Simulate an exception
    throw new CustomException("Custom exception occurred");
});

CompletableFuture<Integer> handledFuture = future.exceptionally(ex -> {
    if (ex instanceof CustomException) {
        // Custom handling for the specific exception
        System.err.println("Custom Exception: " + ex.getMessage());
        return -1;
    } else {
        // Handle other exceptions generically
        System.err.println("Generic Exception: " + ex.getMessage());
        return -2;
    }
});

handledFuture.thenAccept(result -> System.out.println("Result: " + result));


在这个例子中，我们对自定义异常的处理与其他异常不同。您可以根据特定的用例定制异常处理逻辑。

结论

Java CompletableFuture为异步代码中处理异常提供了强大的工具。通过使用诸如exceptionally()、handle()之类的方法，并将它们与completeOnTimeout()和orTimeout()等超时机制结合使用，您可以构建具有优雅错误处理能力的强健且响应灵敏的应用程序。

了解异常如何通过CompletableFuture链传播以及如何有效地处理它们对于在Java中编写可靠的异步代码至关重要。通过这些见解和示例，您将能够完全掌握CompletableFuture中的异常处理，并开发出健壮的并发应用程序。

推荐阅读： 阿里巴巴面经（55）

本文链接： 掌握Java CompletableFuture中的异常处理：见解和示例

相关文章：

LTS JDK 21 特性 如何从Spring Boot应用程序验证数据库连接 处理Javax迁移到Jakarta的最佳实践 一个解决企业开发痛点的PDF框架 使用Spring WebFlux拥抱响应式编程 探索IBM App Connect Enterprise 12.0.12.0 Java 并行 GC 调优 Marco Codes Live: Gavin King 和 Hibernate 6.3 [视频] 探索 IBM App 连接企业 12.0.9.0 释放Spring Cloud的微服务之力

热门文章