CompletableFuture 使用详解

CompletableFuture 使用详解

1. 简介

CompletableFuture 是 Java 8 中的一个类，提供了一种更为简洁和灵活的方式来处理异步任务和并发编程。它可以用于启动异步计算，处理计算完成后的结果，组合多个计算，以及处理异常等。
主要使用场景

• 异步计算：用于异步执行任务而不阻塞主线程。 并发任务管理：处理多个并发任务，并协调它们的结果。
• 复杂的异步流程：处理多个阶段的计算，每个阶段的结果依赖于前一个阶段。 CompletableFuture

2. 创建 CompletableFuture

可以通过多种方式创建 CompletableFuture 实例：

2.1 创建一个已经完成的 CompletableFuture

CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hello, World!");

2.2 使用工厂方法创建异步任务

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步执行任务
});

2.3 使用 supplyAsync 创建异步计算任务

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    // 返回计算结果
    return 123;
});

3. 处理结果

CompletableFuture 提供了多种方法来处理异步任务的结果。

3.1 thenApply 和 thenApplyAsync

用于处理计算完成后的结果，并返回一个新的 CompletableFuture。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> result = future.thenApplyAsync(value -> value * 2);
result.thenAccept(System.out::println);  // 输出 20

3.2 thenAccept 和 thenAcceptAsync

用于处理计算完成后的结果，但不返回新的 CompletableFuture。

CompletableFuture.supplyAsync(() -> "Hello")
    .thenAccept(result -> System.out.println(result));  // 输出 "Hello"

3.3 thenCombine 和 thenCombineAsync

用于组合两个 CompletableFuture 的结果。

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);
CompletableFuture<Integer> combined = future1.thenCombine(future2, (x, y) -> x + y);
combined.thenAccept(System.out::println);  // 输出 30

4. 异常处理

4.1 exceptionally

用于处理异步计算中的异常。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("Exception occurred!");
    return 1;
}).exceptionally(ex -> {
    System.err.println(ex.getMessage());
    return 0;
});

4.2 handle

handle 方法既处理计算结果，也处理异常。

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("Exception occurred!");
    return 1;
}).handle((result, ex) -> {
    if (ex != null) {
        System.err.println(ex.getMessage());
        return 0;
    }
    return result;
});

5. 等待多个任务

5.1 allOf

用于等待所有的 CompletableFuture 完成。

C

ompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
    // 任务1
});
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
    // 任务2
});
CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
allOf.join();  // 阻塞，直到所有任务完成

5.2 anyOf

用于等待第一个 CompletableFuture 完成。

CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
    // 任务1
});
CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
    // 任务2
});
CompleableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2);
anyOf.join();  // 阻塞，直到任意一个任务完成

6.使用示例

 ExecutorService executor = Executors.newFixedThreadPool(resourceConfig.getThreadNum());
                List<Object>> list = Lists.newArrayList<>();
                CompletableFuture<?>[] tasks = list.stream()
                        .map(item -> CompletableFuture.runAsync(() -> processRecords(item), executor))
                        .toArray(CompletableFuture[]::new);
                CompletableFuture.allOf(tasks).join();
                executor.shutdown();