目录
CompletableFuture高级模式详解
1. CompletableFuture基础概念
1.1 什么是CompletableFuture？
1.2 异步编程基础
1.3 CompletableFuture与Future的对比
2. 创建CompletableFuture
2.1 基本创建方法
2.2 使用异步方法创建
2.3 指定执行器
3. 转换和链式操作
3.1 thenApply - 转换结果
3.2 thenAccept - 消费结果
3.3 thenRun - 执行后续操作
3.4 异步转换操作
4. 组合多个CompletableFuture
4.1 thenCompose - 顺序组合
4.2 thenCombine - 并行组合
4.3 allOf - 等待所有完成
4.4 anyOf - 等待任一完成
5. 异常处理
5.1 exceptionally - 简单异常处理
5.2 handle - 处理结果和异常
5.3 whenComplete - 不改变结果的监听
6. 超时处理
6.1 使用orTimeout方法（Java 9+）
6.2 使用completeOnTimeout方法（Java 9+）
6.3 Java 8中的超时处理
7. 异步执行与线程池
7.1 CompletableFuture默认线程池
7.2 自定义线程池
7.3 异步方法与线程池
8. 高级模式与实战案例
8.1 优雅的API调用模式
8.2 并行任务处理模式
8.3 重试模式
8.4 依赖关系处理模式
9. 最佳实践与常见陷阱
9.1 最佳实践
9.2 常见陷阱
10. 小结
进一步学习资源
1. CompletableFuture基础概念
1.1 什么是CompletableFuture？
CompletableFuture 是Java 8引入的一个类，实现了 Future 和 CompletionStage 接口，提供了一种更加强大和灵活的方式来进行异步编程。它解决了传统 Future 的多个限制：
- 传统
Future不能手动完成 - 传统
Future不支持链式操作 - 传统
Future没有提供异常处理机制
1.2 异步编程基础
异步编程允许程序在执行耗时操作时不阻塞主线程，提高程序的响应性和性能。异步编程的核心概念：
- 非阻塞操作：调用后立即返回，不等待执行完成
- 回调机制：任务完成后执行特定的代码
- 并行执行：多个任务同时执行
- 事件驱动：基于事件的处理模型
1.3 CompletableFuture与Future的对比
| 特性 | Future | CompletableFuture |
|---|---|---|
| 手动完成 | ❌ | ✅ |
| 链式操作 | ❌ | ✅ |
| 异常处理 | ❌ | ✅ |
| 组合多个Future | ❌ | ✅ |
| 超时处理 | 需要额外代码 | 内置支持 |
| 回调函数 | ❌ | ✅ |
2. 创建CompletableFuture
2.1 基本创建方法
// 创建一个空的CompletableFuture
CompletableFuture<String> future = new CompletableFuture<>();
// 手动完成一个Future
future.complete("结果");
// 创建一个已完成的Future
CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("已完成");
2.2 使用异步方法创建
// 不返回结果的异步任务
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
System.out.println("异步任务在执行中...");
// 执行耗时操作
});
// 返回结果的异步任务
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
System.out.println("异步任务在执行中...");
// 执行耗时操作
return "操作结果";
});
2.3 指定执行器
ExecutorService executor = Executors.newFixedThreadPool(5);
// 使用自定义线程池执行异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
System.out.println("使用自定义线程池: " + Thread.currentThread().getName());
return "操作结果";
}, executor);
3. 转换和链式操作
3.1 thenApply - 转换结果
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
// 转换结果，String -> String
CompletableFuture<String> future2 = future.thenApply(s -> s + " World");
// 转换结果，String -> Integer
CompletableFuture<Integer> future3 = future.thenApply(String::length);
3.2 thenAccept - 消费结果
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> "Hello")
.thenAccept(s -> System.out.println("得到结果: " + s));
// 不返回结果，仅执行操作
3.3 thenRun - 执行后续操作
CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> "Hello")
.thenRun(() -> System.out.println("操作完成"));
// 不接收参数，也不返回结果
3.4 异步转换操作
// 异步执行thenApply
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
.thenApplyAsync(s -> {
System.out.println("转换操作线程: " + Thread.currentThread().getName());
return s + " World";
});
// 异步执行thenAccept
CompletableFuture<Void> future2 = CompletableFuture.supplyAsync(() -> "Hello")
.thenAcceptAsync(s -> {
System.out.println("消费操作线程: " + Thread.currentThread().getName());
System.out.println("得到结果: " + s);
});
4. 组合多个CompletableFuture
4.1 thenCompose - 顺序组合
CompletableFuture<String> getUserInfo(String userId) {
return CompletableFuture.supplyAsync(() -> "用户信息: " + userId);
}
CompletableFuture<String> getOrderInfo(String userInfo) {
return CompletableFuture.supplyAsync(() -> userInfo + " 的订单");
}
// 串行执行两个异步操作，第二个操作依赖第一个操作的结果
CompletableFuture<String> result = getUserInfo("12345")
.thenCompose(this::getOrderInfo);
4.2 thenCombine - 并行组合
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
// 并行执行两个异步操作，并合并它们的结果
CompletableFuture<String> result = future1.thenCombine(future2, (s1, s2) -> s1 + " " + s2);
4.3 allOf - 等待所有完成
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "任务1");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "任务2");
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "任务3");
// 等待所有任务完成
CompletableFuture<Void> allDone = CompletableFuture.allOf(future1, future2, future3);
// 等待完成后获取所有结果
CompletableFuture<List<String>> results = allDone.thenApply(v -> {
return Stream.of(future1, future2, future3)
.map(CompletableFuture::join) // join不会抛出检查异常
.collect(Collectors.toList());
});
4.4 anyOf - 等待任一完成
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "任务1";
});
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "任务2";
});
// 任一任务完成即完成
CompletableFuture<Object> anyResult = CompletableFuture.anyOf(future1, future2);
5. 异常处理
5.1 exceptionally - 简单异常处理
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
if (Math.random() > 0.5) {
throw new RuntimeException("操作失败");
}
return "操作成功";
}).exceptionally(ex -> {
System.out.println("异常: " + ex.getMessage());
return "默认值"; // 出现异常时返回默认值
});
5.2 handle - 处理结果和异常
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
if (Math.random() > 0.5) {
throw new RuntimeException("操作失败");
}
return "操作成功";
}).handle((result, ex) 
