20.jdk源码阅读之CompletableFuture

至真源

已于 2024-07-29 18:15:28 修改

阅读量767

点赞数 20

分类专栏： JDK源码文章标签： java 开发语言

于 2024-07-26 09:58:27 首次发布

本文为至真源原创，转载请注明出处，谢谢！

本文链接：https://blog.youkuaiyun.com/yunkongbian2616/article/details/140707192

版权

JDK源码专栏收录该内容

31 篇文章

订阅专栏

1. 写在前面

CompletableFuture 是 Java 8 引入的一个强大的类，用于异步编程和并发处理。它提供了丰富的 API，用于处理异步任务、组合多个异步任务、处理任务结果和异常等。按照惯例，在正式阅读源码前请大家先思考几个问题：

如何组合多个 CompletableFuture？
如何处理 CompletableFuture 的异常？
CompletableFuture 的 join 和 get 有什么区别？
如何等待多个 CompletableFuture 完成？
CompletableFuture 的优缺点是什么？
CompletableFuture 与 Future 有什么区别？
如何使用 CompletableFuture 实现异步回调？
如何使用 CompletableFuture 实现超时控制？

2. 全局视角

在这里插入图片描述

2.1 Future

CompletableFuture 实现了 java.util.concurrent.Future 接口，这意味着它可以用来表示一个异步计算的结果，并提供了基本的结果获取和任务取消功能。
Future 接口提供了以下主要方法：

T get() throws InterruptedException, ExecutionException: 阻塞当前线程，直到任务完成并返回结果。
T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException: 在指定的时间内阻塞当前线程，直到任务完成并返回结果，如果超时则抛出 TimeoutException。
boolean cancel(boolean mayInterruptIfRunning): 尝试取消任务。
boolean isCancelled(): 返回任务是否已被取消。
boolean isDone(): 返回任务是否已完成。

2.2 CompletionStage

CompletableFuture 还实现了 java.util.concurrent.CompletionStage 接口，这提供了一个框架，用于定义和链接一系列异步计算步骤。
CompletionStage 接口提供了丰富的方法用于链式调用和异步任务的组合，包括但不限于：

CompletionStage thenApply(Function<? super T,? extends U> fn): 在当前任务完成后，应用一个函数到结果上，并返回一个新的 CompletionStage。
CompletionStage thenAccept(Consumer<? super T> action): 在当前任务完成后，使用结果执行一个操作，并返回一个新的 CompletionStage。
CompletionStage thenRun(Runnable action): 在当前任务完成后，执行一个 Runnable 操作。
CompletionStage exceptionally(Function<Throwable,? extends T> fn): 在当前任务发生异常时，应用一个函数到异常上，并返回一个新的 CompletionStage。
CompletionStage thenCompose(Function<? super T,? extends CompletionStage> fn): 在当前任务完成后，应用一个函数到结果上，该函数返回一个新的 CompletionStage，并返回这个新的 CompletionStage。
CompletionStage thenCombine(CompletionStage<? extends U> other, BiFunction<? super T,? super U,? extends V> fn): 在两个 CompletionStage 都完成后，应用一个函数到两个结果上，并返回一个新的 CompletionStage。

2.3 CompletableFuture 的扩展方法

除了实现 Future 和 CompletionStage 接口的方法外，CompletableFuture 还提供了许多扩展方法来简化异步编程：

static CompletableFuture supplyAsync(Supplier supplier): 异步执行一个任务，并返回一个 CompletableFuture。
static CompletableFuture runAsync(Runnable runnable): 异步执行一个 Runnable 任务，并返回一个 CompletableFuture。
CompletableFuture complete(T value): 手动完成任务并设置结果。
CompletableFuture completeExceptionally(Throwable ex): 手动完成任务并设置异常。
CompletableFuture orTimeout(long timeout, TimeUnit unit): 设置超时时间。
CompletableFuture completeOnTimeout(T value, long timeout, TimeUnit unit): 在超时后完成任务并设置结果。

3. 从使用说起

3.1 异步任务的创建

3.1.1 使用 runAsync 执行没有返回值的异步任务

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("Running in a separate thread.");
});

3.1.2 使用 supplyAsync 执行有返回值的异步任务

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "Hello, World!";
});

3.2 串联多个异步任务

3.2.1 使用 thenApply 处理前一个任务的结果并返回新的结果

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(result -> result + " World")
    .thenApply(result -> result + "!");

3.2.2 使用 thenCompose 将两个异步操作串联起来

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " World"));

3.3 并行执行多个异步任务

3.3.1 使用 thenCombine 合并两个并行的异步任务的结果

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

CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + " " + result2);

3.3.2 使用 allOf 等待多个异步任务完成

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

CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
allOf.join(); // 等待所有任务完成

String result1 = future1.join();
String result2 = future2.join();

3.4 异常处理

3.4.1 使用 exceptionally 处理异常

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Exception occurred");
    }
    return "Result";
}).exceptionally(ex -> {
    System.out.println("Exception: " + ex.getMessage());
    return "Default Result";
});

3.4.2 使用 handle 同时处理结果和异常

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Exception occurred");
    }
    return "Result";
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("Exception: " + ex.getMessage());
        return "Default Result";
    }
    return result;
});

3.5 超时控制

3.5.1 使用 orTimeout 设置超时时间

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(5000); // 模拟耗时操作
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Result";
}).orTimeout(3, TimeUnit.SECONDS);

try {
    String result = future.get();
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

3.6 应用场景

3.6.1 异步调用远程服务

在微服务架构中，通常需要调用多个远程服务来获取数据。使用 CompletableFuture 可以并行调用这些服务，提高响应速度。

CompletableFuture<String> userFuture = CompletableFuture.supplyAsync(() -> {
    return getUserInfo(userId); // 异步调用获取用户信息
});

CompletableFuture<String> orderFuture = CompletableFuture.supplyAsync(() -> {
    return getOrderInfo(orderId); // 异步调用获取订单信息
});

CompletableFuture<Void> allOf = CompletableFuture.allOf(userFuture, orderFuture);
allOf.join();

String userInfo = userFuture.join();
String orderInfo = orderFuture.join();

3.6.2 异步任务链

在复杂的业务逻辑中，可能需要执行一系列依赖关系的异步任务。使用 CompletableFuture 可以轻松地将这些任务串联起来。

CompletableFuture.supplyAsync(() -> {
    return fetchDataFromServiceA(); // 异步获取数据
}).thenApply(data -> {
    return processData(data); // 处理数据
}).thenAccept(result -> {
    saveResult(result); // 保存结果
});

3.6.3 异步处理和异常处理

在处理异步任务时，可能会遇到异常情况。使用 CompletableFuture 的异常处理机制，可以优雅地处理这些异常。

CompletableFuture.supplyAsync(() -> {
    return fetchDataFromServiceA();
}).thenApply(data -> {
    return processData(data);
}).exceptionally(ex -> {
    logError(ex);
    return "Default Result";
}).thenAccept(result -> {
    saveResult(result);
});

4. CompletableFuture 的 join 和 get 有什么区别？

get 方法会抛出受检异常 InterruptedException 和 ExecutionException，需要显式处理。
join 方法会抛出未受检异常 CompletionException，不需要显式处理。

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

try {
    String result = future.get();
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

String result = future.join(); // 不需要显式处理异常