文章目录
- 1 CompletableFuture与线程池之间有什么关系？
- 2 如何优化CompletableFuture的性能？
- 3 实际项目中，以并行执行多个HTTP请求为例，你会如何优雅使用CompletableFuture 解决问题？
1 CompletableFuture与线程池之间有什么关系？
CompletableFuture 和线程池的关系是，CompletableFuture 用来定义和管理异步任务，而线程池则负责实际执行这些任务。
想象一下，
CompletableFuture是一个能够在未来某个时刻完成任务的代表。它可以让代码更容易处理异步操作，也就是任务在后台运行，不会阻塞主线程。
在进行耗时的网络请求或者复杂的计算时，就可以用 CompletableFuture 来处理这些操作，并在任务完成时取得结果。
线程池则是负责实际执行这些任务的地方。它可以被看作是一组可以执行任务的工作线程。这些线程在后台待命，等待被分配任务。当任务到达线程池时，线程池会从这些线程中选择一个，分配任务，然后开始执行。
创建一个 CompletableFuture 时，通常需要指定一个线程池来处理实际的任务。
// 创建了一个包含四个线程的线程池
ExecutorService executor = Executors.newFixedThreadPool(4);
// 使用 supplyAsync 方法创建一个 CompletableFuture 时，可以传递一个 Executor，这个 Executor 就是线程池的实现
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 模拟耗时的任务
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return "Task Completed";
}, executor);
线程池的作用在于管理这些线程的生命周期和调度，避免每次执行任务时都创建新的线程，这样可以提高效率，减少资源消耗。线程池中的线程会在任务完成后继续等待新的任务，从而避免了频繁的线程创建和销毁开销。
当任务完成时，CompletableFuture 会获取任务的结果。使用线程池执行的任务可以利用 CompletableFuture 提供的各种功能，比如处理异常、组合多个异步任务等：
// 在任务完成时打印结果，如果有异常发生，则会打印错误信息
future.thenAccept(result -> {
System.out.println("Result: " + result);
}).exceptionally(ex -> {
System.err.println("Error: " + ex.getMessage());
return null;
});
2 如何优化CompletableFuture的性能？
优化 CompletableFuture 的性能需要关注几个关键方面。
一个重要的策略是合理使用线程池。可以创建一个固定大小的线程池来避免过多的线程切换开销，通过 Executors.newFixedThreadPool(int nThreads) 创建线程池，nThreads 的值应与系统核心数匹配，确保资源得到有效利用。
团队工作效率不仅仅取决于每个人的能力，还与分配的资源有关。如果团队人数太多或太少，都会影响整体效率。
默认情况下，supplyAsync 使用的是公共的 ForkJoinPool，但在高负载时，这可能成为瓶颈，可以考虑创建并配置自定义的线程池来适应具体的任务负载：
public static void main(String[] args) {
ExecutorService customThreadPool = Executors.newFixedThreadPool(10);
CompletableFuture.supplyAsync(() -> fetchData("http://api.com"), customThreadPool)
.thenAccept(result -> System.out.println(result));
// 关闭线程池
customThreadPool.shutdown();
}
private static String fetchData(String url) {
// 模拟 HTTP 请求
return "Response from " + url;
}
处理多个异步任务时，合并操作能够减少资源浪费。使用 CompletableFuture.allOf(futures) 可以等待所有给定的 CompletableFuture 完成，这样可以减少不必要的等待时间。如果只需要等待其中一个任务完成，CompletableFuture.anyOf(futures) 是更合适的选择，它会在第一个完成的任务完成后立即返回结果。
在一个团队中，如果每个人都独立完成自己的任务，最终合并结果的过程可能会很麻烦。
如果需要同时处理多个异步任务，可以使用 allOf 合并它们。比如，如果有多个 API 请求可以并行处理，可以像这样将它们合并：
public static void main(String[] args) {
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> fetchData("http://api1.com"));
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> fetchData("http://api2.com"));
CompletableFuture<Void> allOf = CompletableFuture.allOf(future1, future2);
allOf.thenRun(() -> {
try {
System.out.println("Result from API 1: " + future1.get());
System.out.println("Result from API 2: " + future2.get());
} catch (Exception e) {
e.printStackTrace();
}
});
}
private static String fetchData(String url) {
// 模拟 HTTP 请求
return "Response from " + url;
}
避免阻塞操作也至关重要。在异步操作中，阻塞线程会影响整体性能。尽量将耗时操作放在异步任务内部，而不是在主线程中进行等待，这样可以减少线程占用，提高执行效率。
想象一个在办公室里的团队成员，他们需要处理多项任务。如果有人在处理一个任务时不停地打电话查询进度，这就像是阻塞操作，导致其他任务也被拖慢。
当需要链式处理多个异步结果时，thenCompose 方法可以提供更高的性能和清晰度。thenCompose 用于处理返回的 CompletableFuture，可以避免多层嵌套，使得代码更简洁。
CompletableFuture.supplyAsync(() -> {
// 第一个异步任务
return "Hello";
}).thenCompose(result -> {
// 处理第一个任务的结果，并返回另一个 CompletableFuture
return CompletableFuture.supplyAsync(() -> result + " World");
}).thenAccept(System.out::println);
处理异常时，使用 exceptionally 或 handle 方法可以提升代码的健壮性。exceptionally 可以处理任务执行中的异常，handle 既处理正常结果也处理异常。这样能确保任务在遇到问题时仍能正常运行或提供有效的错误信息。
任务拆分也是一种优化策略。将大任务拆分成多个小任务可以提高并发性和效率。这样做能更好地利用线程池，并且可以更精确地控制任务的执行。
监控和调优是优化性能的基础。使用工具来监控线程池的使用情况和 CompletableFuture 的执行状态，可以及时发现并解决瓶颈问题，通过实际测试和分析，调整线程池大小和任务拆分策略，从而实现最佳性能。
3 实际项目中，以并行执行多个HTTP请求为例，你会如何优雅使用CompletableFuture 解决问题？
在实际项目中，使用
CompletableFuture来并行执行多个 HTTP 请求可以显著提高效率。比如，考虑一个场景，需要从多个 API 获取数据。
分析：创建 CompletableFuture 实例并执行异步 HTTP 请求时，可以使用 CompletableFuture.supplyAsync 方法。这个方法接受一个 Supplier，在这个 Supplier 中执行实际的 HTTP 请求。每个请求都可以用一个 CompletableFuture 处理，从而实现并行执行。
如何处理多个 HTTP 请求：
import java.util.concurrent.CompletableFuture;
import java.util.List;
public class AsyncHttpRequests {
public static void main(String[] args) {
// 包含了多个要请求的 URL
List<String> urls = List.of("http://api1.com", "http://api2.com", "http://api3.com");
// 创建了一组 CompletableFuture 实例，每一个都负责异步执行一个 HTTP 请求
// fetchData(url) 方法模拟了实际的 HTTP 请求逻辑，这里可以用真实的 HTTP 客户端代替
List<CompletableFuture<String>> futures = urls.stream()
.map(url -> CompletableFuture.supplyAsync(() -> fetchData(url)))
.toList();
// 等待所有异步请求完成，接收一个 CompletableFuture 数组，并在所有请求完成后继续执行后续操作。
CompletableFuture<Void> allOf = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
// thenApply 方法将所有请求结果汇集起来，提取每个 CompletableFuture 的结果并汇集成一个列表
CompletableFuture<List<String>> allOfResult = allOf.thenApply(v ->
futures.stream()
.map(CompletableFuture::join)
.toList()
);
// 将所有结果打印到控制台
allOfResult.thenAccept(results -> {
results.forEach(System.out::println);
});
}
private static String fetchData(String url) {
// 模拟 HTTP 请求，这里应使用实际的 HTTP 请求逻辑
return "Response from " + url;
}
}
使用 CompletableFuture 可以优雅地处理多个异步任务，通过合并结果和处理异常，可以确保程序在高负载时表现稳定。
必须从过去的错误学习教训而非依赖过去的成功
