07-CompletableFuture异步编程实战与陷阱规避

CompletableFuture异步编程实战与陷阱规避

一、为什么需要异步编程？

1. 同步 vs 异步性能对比

场景	同步调用耗时	异步调用耗时	提升比例
3次顺序HTTP请求	900ms	300ms	300%
数据库查询+文件IO	450ms	150ms	300%
多服务聚合结果	1200ms	400ms	300%

2. 回调地狱的演进

java 复制代码

// 回调地狱示例
userService.getUser(id, user -> {
    orderService.getOrders(user, orders -> {
        paymentService.getPayments(orders, payments -> {
            // 嵌套层级越来越深...
        });
    });
});

// CompletableFuture解决方案
CompletableFuture.supplyAsync(() -> userService.getUser(id))
    .thenCompose(user -> orderService.getOrdersAsync(user))
    .thenAccept(orders -> paymentService.processPayments(orders));

二、核心API全解析

1. 创建异步任务

方法	作用描述	线程池控制
`supplyAsync(Supplier)`	带返回值的异步任务	可指定Executor
`runAsync(Runnable)`	无返回值的异步任务	默认ForkJoinPool.commonPool()
`completedFuture(T)`	创建已完成的Future	-

java 复制代码

// 自定义线程池示例
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 耗时操作
    return "result";
}, executor);

2. 任务链式组合

组合方法	作用描述	异常处理特性
`thenApply(Function)`	同步转换结果	异常会中断整个链
`thenCompose(Function)`	异步嵌套Future	支持异常传播
`thenCombine(CompletionStage, BiFunction)`	双任务结果合并	任一任务异常则中断

java 复制代码

// 组合操作示例
CompletableFuture<Integer> total = getUserCount()
    .thenCombine(getOrderCount(), (userCount, orderCount) -> {
        return userCount + orderCount;
    });

三、异常处理机制

1. 异常传播机制

css 复制代码

graph LR
    A[任务A异常] --> B[中断后续thenApply]
    B --> C[触发handle/handler]
    C --> D[恢复默认值或新异常]

2. 处理方案对比

方法	作用描述	适用场景
`exceptionally(Function)`	捕获异常并返回默认值	简单降级逻辑
`handle(BiFunction)`	同时处理正常结果和异常	需要统一处理
`whenComplete(BiConsumer)`	观察结果但不改变结果	日志记录等副作用操作

java 复制代码

// 异常处理示例
CompletableFuture.supplyAsync(() -> {
        if (new Random().nextBoolean()) {
            throw new RuntimeException("模拟异常");
        }
        return "success";
    })
    .exceptionally(ex -> {
        System.out.println("捕获异常: " + ex.getMessage());
        return "default";
    })
    .thenAccept(System.out::println);

四、高级组合模式

1. 多任务聚合

方法	行为特点
`allOf(CompletableFuture...)`	等待所有任务完成
`anyOf(CompletableFuture...)`	任意一个任务完成即继续

java 复制代码

// 电商商品详情页聚合示例
CompletableFuture<Product> productFuture = getProductAsync(id);
CompletableFuture<List<Review>> reviewsFuture = getReviewsAsync(id);
CompletableFuture<Recommendation> recFuture = getRecommendationsAsync(id);

CompletableFuture<Void> all = CompletableFuture.allOf(
    productFuture, reviewsFuture, recFuture);

all.thenRun(() -> {
    Product p = productFuture.join();
    List<Review> reviews = reviewsFuture.join();
    Recommendation rec = recFuture.join();
    renderPage(p, reviews, rec);
});

2. 超时控制实现

java 复制代码

// JDK9+ 原生支持
future.orTimeout(1, TimeUnit.SECONDS)
      .exceptionally(ex -> "超时默认值");

// JDK8兼容方案
CompletableFuture.supplyAsync(() -> {
    try {
        return longRunningTask();
    } finally {
        timeoutFuture.cancel(true);
    }
}).acceptEither(timeoutFuture, result -> {
    // 处理正常结果
});

五、性能陷阱与最佳实践

1. 线程池选择策略

场景	推荐线程池	理由
IO密集型任务	固定大小线程池（>CPU核数）	避免等待IO时CPU闲置
CPU密集型任务	工作窃取线程池	利用多核并行计算
混合型任务	自定义线程池	根据业务特点调整

2. 常见陷阱清单

阻塞线程池：默认ForkJoinPool的共用特性

java 复制代码

// 错误用法：会阻塞公共线程池
CompletableFuture.runAsync(() -> {
    Thread.sleep(1000); // 阻塞调用
});

// 正确方案：使用自定义线程池
ExecutorService ioExecutor = Executors.newCachedThreadPool();
CompletableFuture.runAsync(() -> {
    try {
        TimeUnit.SECONDS.sleep(1); // 使用可中断休眠
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}, ioExecutor);

丢失异常：未处理的异常会被静默吞噬

java 复制代码

future.exceptionally(ex -> {
    log.error("任务失败", ex); // 必须记录日志
    return null;
});

六、Spring整合实战

1. @Async与CompletableFuture

java 复制代码

@Service
public class OrderService {
    @Async("taskExecutor") // 指定线程池
    public CompletableFuture<Order> getOrderAsync(String id) {
        return CompletableFuture.completedFuture(queryOrder(id));
    }
}

// 调用方
orderService.getOrderAsync("123")
    .thenApply(Order::getItems)
    .thenAccept(this::processItems);

2. WebFlux响应式整合

java 复制代码

@GetMapping("/user/{id}/profile")
public Mono<UserProfile> getUserProfile(@PathVariable String id) {
    return Mono.fromFuture(
        userService.getUserAsync(id)
            .thenCompose(user -> 
                statsService.getUserStatsAsync(user.getId())
                    .thenApply(stats -> new UserProfile(user, stats))
    );
}

七、QA高频问题

💬 Q1：如何处理多个异步任务的异常？

✅ 答案：

为每个任务单独添加exceptionally处理

使用handle统一处理：

java 复制代码

CompletableFuture.allOf(task1, task2)
    .handle((result, ex) -> {
        if (ex != null) {
            // 检查具体哪个任务失败
            if (task1.isCompletedExceptionally()) {
                // 处理task1异常
            }
            return "fallback";
        }
        return result;
    });

💬 Q2：为什么我的回调没有执行？

✅ 检查清单：

主线程是否提前退出（添加future.join()）
是否遗漏了终端操作（如thenAccept）
线程池是否已被关闭

💬 Q3：与RxJava如何选择？

✅ 对比决策表：

维度	CompletableFuture	RxJava
学习曲线	低（JDK内置）	高（响应式编程概念）
适用场景	离散异步任务	数据流处理
背压支持	不支持	原生支持
操作符丰富度	基础组合操作	丰富的流操作符

最佳实践总结：

始终指定业务专属线程池（避免影响公共线程池）
为每个异步链添加异常处理
复杂场景优先使用thenCompose而非thenApply
监控线程池状态（如Spring Boot Actuator）

通过jstack -l <pid>可查看CompletableFuture实际使用的线程栈