CompletableFuture.runAsync如何实现串行执行？

Question

在使用 `CompletableFuture.runAsync` 时，多个异步任务默认是并行执行的。常见的问题是：如何确保多个 `runAsync` 任务按顺序串行执行？例如，希望第二个任务在第一个任务完成后才开始，而不是同时触发。直接连续调用 `runAsync` 并不能实现串行，因为它们各自提交到线程池后独立运行。开发者常误以为链式调用能保证顺序，但实际上需通过 `thenRun`、`thenRunAsync` 等组合方法显式串联任务依赖关系。如何正确使用这些方法结合 `runAsync` 实现真正的串行执行？

Answer 1

一、理解 CompletableFuture.runAsync 的并行本质

在 Java 8 引入的 CompletableFuture 中，runAsync(Runnable) 方法用于提交一个无返回值的异步任务到默认的 ForkJoinPool 线程池中执行。开发者常误以为如下代码能实现串行执行：

CompletableFuture.runAsync(() -> System.out.println("Task 1"))
                    .runAsync(() -> System.out.println("Task 2"));

然而，这并不会按预期串行执行。第二个 runAsync 并非基于前一个任务的结果调用，而是创建了一个全新的独立 CompletableFuture 实例，因此两个任务将并行运行。

关键点在于：连续调用静态方法 runAsync 不构成任务依赖链，它们彼此无关联，各自立即提交到线程池。

二、为何链式调用不等于顺序执行？

以下表格对比了常见误解与实际行为：

写法	意图	实际行为
runAsync(t1).runAsync(t2)	先执行 t1 再执行 t2	t1 和 t2 并行启动
runAsync(t1).thenRun(t2)	t1 完成后执行 t2	正确串行（同一线程或主线程）
runAsync(t1).thenRunAsync(t2)	t1 后异步执行 t2	串行且使用不同线程
runAsync(t1); runAsync(t2);	依次触发	完全并行，无依赖

三、实现串行执行的核心机制：组合式异步编程

要实现真正的串行，必须利用 CompletableFuture 提供的“组合”方法来建立任务间的依赖关系。主要方法包括：

• thenRun(Runnable)：当前任务完成后同步执行下一个 Runnable
• thenRunAsync(Runnable)：当前任务完成后异步执行下一个 Runnable（可指定线程池）
• thenCompose / thenCombine：用于更复杂的串行或合并场景

示例代码展示如何正确串行化三个任务：

CompletableFuture<Void> chain = CompletableFuture
        .runAsync(() -> {
            System.out.println("Task 1 开始");
            sleep(1000);
            System.out.println("Task 1 结束");
        })
        .thenRun(() -> {
            System.out.println("Task 2 开始");
            sleep(800);
            System.out.println("Task 2 结束");
        })
        .thenRunAsync(() -> {
            System.out.println("Task 3 开始（异步线程）");
            sleep(600);
            System.out.println("Task 3 结束");
        });

chain.join(); // 阻塞等待整个链完成

四、线程模型分析：同步 vs 异步回调

使用 thenRun 与 thenRunAsync 在线程调度上有显著差异：

• thenRun：通常由完成前一个任务的线程直接执行后续任务（非严格保证），减少上下文切换，适合轻量操作。
• thenRunAsync：强制将后续任务提交回线程池，确保不会阻塞原线程，适用于耗时较长的回调。

可通过自定义线程池控制资源：

ExecutorService customPool = Executors.newFixedThreadPool(2);

CompletableFuture
    .runAsync(() -> System.out.println("First task"), customPool)
    .thenRunAsync(() -> System.out.println("Second task"), customPool)
    .thenRunAsync(() -> System.out.println("Third task"), customPool)
    .join();

五、流程图：串行执行的任务依赖结构

下图为多个 runAsync 通过组合方法串联后的执行逻辑：

graph LR
            A[Start] --> B["runAsync(Task1)"]
            B --> C["thenRun(Task2)"]
            C --> D["thenRunAsync(Task3)"]
            D --> E["Final Completion"]
            style B fill:#f9f,stroke:#333
            style C fill:#bbf,stroke:#333
            style D fill:#f96,stroke:#333

六、高级模式：动态构建串行任务链

当任务数量不确定时，可通过循环动态构建串行链：

List<Runnable> tasks = Arrays.asList(
    () -> log("初始化"),
    () -> log("加载配置"),
    () -> log("连接数据库"),
    () -> log("启动服务")
);

CompletableFuture<Void> chain = CompletableFuture.completedFuture(null);
for (Runnable task : tasks) {
    chain = chain.thenRunAsync(task, customPool);
}
chain.join();

该模式广泛应用于微服务启动流程、批处理作业等需严格顺序的场景。

七、陷阱与最佳实践

1. 避免滥用 join() 或 get() 在主线程中阻塞，应结合 whenComplete 使用非阻塞回调。
2. 注意异常传播：thenRun 不会接收上一阶段的异常，建议配合 exceptionally 处理错误。
3. 若某环节需返回数据，应改用 supplyAsync + thenApply 模型。
4. 监控长链式调用的性能开销，必要时拆分为子链并行处理。
5. 始终关闭自定义线程池以防止资源泄漏。

通过合理设计任务依赖结构，可以充分发挥 CompletableFuture 在复杂异步流程中的编排能力。