CompletableFuture高级模式详解

目录

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)