1. Java CompletableFuture 全流程解读：从异步调度到结果收集
1.1 异步调度的工作原理
Java CompletableFuture 是对异步任务的“承诺”，它在内部通过任务阶段链条逐步推进，最终在需要时产出结果或异常。异步调度的核心在于用非阻塞的方式启动工作，并把后续处理以阶段（stage）方式接入，从而避免长时间阻塞主线程。
在默认场景下，CompletableFuture 的异步任务会由 ForkJoinPool.commonPool() 等待执行，除非显式提供自定义的 Executor。非阻塞执行使得你可以把复杂工作流以链式结构拼接起来，实现高吞吐。
下面的代码直观展示了如何创建一个异步任务，并将结果通过后续阶段处理，整个过程在主线程之外完成。核心概念是非阻塞启动与阶段化组合。
// 异步调度示例（默认线程池）
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {// 模拟耗时任务Thread.sleep(100);return 42;
});2. 任务创建与首次执行
2.1 使用 supplyAsync 启动任务
使用 supplyAsync 可以在异步线程中执行一个返回结果的任务，返回值类型为 CompletableFuture，调用方立即获得一个未来对象，不会阻塞当前线程。
这是 异步调度 的入口点——从一个普通方法调用转化为一个可组合的任务图。明确返回值让后续阶段能够基于此结果继续计算。
示例展示了最常见的用法：直接返回一个值作为结果，随后通过链式调用进行处理。
CompletableFuture<String> futureName = CompletableFuture.supplyAsync(() -> {// 模拟数据获取return "Alice";
});2.2 指定自定义线程池以控制并发
在并发量较高的场景，给 CompletableFuture 指定一个自定义的 Executor 可以更好地控制并发、避免资源争抢。
通过将任务放入自定义线程池，可以实现对并发度、优先级和超时等的精细化管理。显式线程池的使用有助于稳定化系统行为。
下面的示例展示了如何传入一个固定大小的线程池来执行异步任务。
Executor executor = Executors.newFixedThreadPool(4);
CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> {// 模拟算力任务return 7;
}, executor);3. 任务串行与并行的组合
3.1 thenApply、thenAccept、thenRun 的分支处理
链式调用中，thenApply 用于将前一个阶段的结果转换成新值，返回新的 CompletableFuture；thenAccept 则消费结果但不返回新值；thenRun 则在前一阶段完成后执行一个无参数的操作。通过这些阶段，可以实现数据的转换、副作用处理与最终的行动分离。
示例展示了从字符串结果转换为长度，再进行消费式输出的流程。注意返回类型变化对后续拼接的影响。
CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "hello").thenApply(s -> s.toUpperCase()) // 转换.thenAccept(System.out::println); // 消费输出3.2 thenCompose 与 thenCombine 的差异
thenCompose 实现的是“扁平化的异步序列”：在前一个阶段完成后，返回一个新的 CompletableFuture，并将两个阶段拼接成一个连续的异步流程。这适合需要串行依赖的场景。
thenCombine 则是在两个独立阶段并行完成后，将结果合并成一个新值，适合并行获取并最终汇总的场景。两者的核心差异在于依赖关系：是否需要等待前一个阶段的结果来启动下一个阶段。
// thenCompose：串行依赖
CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> f2 = f1.thenCompose(v -> CompletableFuture.supplyAsync(() -> v * 2));
// 结果是 20// thenCombine：并行汇总
CompletableFuture<Integer> a = CompletableFuture.supplyAsync(() -> 5);
CompletableFuture<Integer> b = CompletableFuture.supplyAsync(() -> 3);
CompletableFuture<Integer> combined = a.thenCombine(b, (x, y) -> x + y); // 结果 84. 结果收集与等待策略
4.1 allOf 与 anyOf 的聚合
allOf 等待多个 CompletableFuture 全部完成后再继续执行，适合需要汇总多源结果的场景；anyOf 在任意一个阶段完成时就继续，适合对响应时间敏感的情况。
通过 allOf 可以实现“等到所有任务都完成再收集结果”的策略，但需要自行提取各自的结果值；通过 anyOf 可以先获得最快的结果再继续处理。
CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "A");
CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> "B");CompletableFuture<Void> all = CompletableFuture.allOf(a, b);
all.thenRun(() -> {String r1 = a.join();String r2 = b.join();System.out.println(r1 + "-" + r2);
});anyOf 的结果是 Object ，需要类型转换；它适合当任意一个任务先完成就可进入后续阶段的场景。
CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> "fast");
CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> "slow");CompletableFuture<Object> first = CompletableFuture.anyOf(a, b);
first.thenAccept(result -> System.out.println(\"最快结果: \" + result));4.2 阻塞获取与非阻塞获取
常用的获取结果方法包括 get、join，以及在就地获取的非阻塞方式 getNow。其中 get 会抛出异常，需要捕获，join 则在异常时把异常包装为未检查异常，通常更便捷。
对于需要非阻塞返回的场景，推荐使用 thenApply/thenAccept/thenRun、以及组合阶段来实现回调式处理。避免在主线程中直接阻塞等待，以保持高并发性能。
CompletableFuture<Integer> f = CompletableFuture.supplyAsync(() -> 7);
try {Integer result = f.get(); // 阻塞获取
} catch (Exception e) {// 处理异常
}5. 异常处理与容错
5.1 exceptionally、handle、whenComplete 的用法
在工作流中，异常是不可避免的。exceptionally 提供对异常的兜底返回，返回替代值；handle 提供对结果和异常的双输入处理，能返回一个新结果；whenComplete 允许在完成时执行副作用（如日志记录），但不改变最终结果。
结合胆量和容错策略，可以让异步流程更健壮。下面的示例展示了在出现异常时提供默认值，并继续链式处理。
CompletableFuture<Integer> cf = CompletableFuture.supplyAsync(() -> {if (new Random().nextBoolean()) throw new RuntimeException("failure");return 1;
}).exceptionally(ex -> {// 提供兜底值return 0;
}).thenApply(v -> v + 10);cf.thenAccept(System.out::println);6. 实战案例：从异步调度到结果收集的完整流程
6.1 场景描述与目标
在实际系统中，常见需求是并行拉取多组数据，随后将结果汇总成一个最终数据结构。使用 Java CompletableFuture 可以实现从异步调度到结果收集的完整流程，同时保持代码的清晰与可维护性。
目标如下：同时发起两个网络请求或计算任务，在两者完成后合并结果，并对可能的异常进行处理，以确保最终产出稳定可用。
import java.util.concurrent.*;
import java.util.*;public class AsyncWorkflowDemo {public static void main(String[] args) {Executor executor = Executors.newFixedThreadPool(4);// 模拟两个独立的异步任务CompletableFuture<String> userFuture = CompletableFuture.supplyAsync(() -> {simulateWork("fetchUserData", 150);return "User{ id: 123, name: Jane }";}, executor);CompletableFuture<Integer> orderFuture = CompletableFuture.supplyAsync(() -> {simulateWork("fetchOrderData", 200);return 42;}, executor);// 合并两个异步结果：先等待两者完成，再进行汇总CompletableFuture<String> reportFuture = userFuture.thenCombine(orderFuture, (user, orderCount) -> {return "Report: " + user + ", Orders: " + orderCount;}).exceptionally(ex -> "Report generation failed: " + ex.getMessage());// 收集最终结果reportFuture.thenAccept(System.out::println);// 给异步任务留出时间执行reportFuture.join();((ExecutorService) executor).shutdown();}private static void simulateWork(String name, int ms) {try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }}
}在上述实战中，并行启动两个任务，通过 thenCombine 将结果合并成最终的报告。如果任意一个任务失败，exceptionally 提供兜底处理，确保整个流程优雅降级。
通过这类模式，你可以把复杂的业务流拆解成若干个可维护的阶段，并以清晰的方式实现“从异步调度到结果收集”的完整流程。核心要点包括：正确选择并发粒度、合理使用 thenCombine/thenCompose、以及完善的异常处理策略。
