📕我是廖志伟，一名Java开发工程师、《Java项目实战——深入理解大型互联网企业通用技术》（基础篇）、（进阶篇）、（架构篇）、《解密程序员的思维密码——沟通、演讲、思考的实践》作者、清华大学出版社签约作家、Java领域优质创作者、优快云博客专家、阿里云专家博主、51CTO专家博主、产品软文专业写手、技术文章评审老师、技术类问卷调查设计师、幕后大佬社区创始人、开源项目贡献者。
📘拥有多年一线研发和团队管理经验，研究过主流框架的底层源码(Spring、SpringBoot、SpringMVC、SpringCloud、Mybatis、Dubbo、Zookeeper)，消息中间件底层架构原理(RabbitMQ、RocketMQ、Kafka)、Redis缓存、MySQL关系型数据库、 ElasticSearch全文搜索、MongoDB非关系型数据库、Apache ShardingSphere分库分表读写分离、设计模式、领域驱动DDD、Kubernetes容器编排等。
📙不定期分享高并发、高可用、高性能、微服务、分布式、海量数据、性能调优、云原生、项目管理、产品思维、技术选型、架构设计、求职面试、副业思维、个人成长等内容。
💡在这个美好的时刻，笔者不再啰嗦废话，现在毫不拖延地进入文章所要讨论的主题。接下来，我将为大家呈现正文内容。
🍊 并发编程核心知识点之 CompletableFuture：概述
在当今的软件开发领域，随着应用复杂性的不断增加，对系统性能的要求也越来越高。特别是在处理大量数据或执行耗时操作时，如何有效地利用系统资源，提高程序的执行效率，成为了一个关键问题。一个典型的场景是，在一个电商平台上，用户下单后，系统需要同时处理订单的生成、库存的更新、物流的跟踪等多个环节。如果这些环节是串行执行的，那么整个订单处理过程将会非常缓慢，用户体验也会大打折扣。为了解决这个问题，引入并发编程技术成为了一种必然趋势。
在Java编程语言中，CompletableFuture 是一个强大的并发编程工具，它提供了异步执行任务的能力，使得开发者可以轻松地构建出高效的并发程序。CompletableFuture 的引入，不仅简化了并发编程的复杂性，而且提高了代码的可读性和可维护性。
介绍 CompletableFuture 的必要性在于，它能够帮助我们更好地理解和利用Java的并发特性，从而在开发过程中避免常见的并发编程陷阱，如死锁、竞态条件等。通过使用 CompletableFuture，我们可以实现任务的异步执行，并且能够方便地处理任务之间的依赖关系，这对于构建高性能、高可用性的系统至关重要。
接下来，我们将深入探讨 CompletableFuture 的概念，分析其优势，并探讨其在实际开发中的适用场景。首先，我们会介绍 CompletableFuture 的基本概念，包括其如何表示异步操作的结果以及如何与其他任务进行组合。随后，我们将详细阐述 CompletableFuture 相比于传统并发模型的优势，例如非阻塞的执行方式、丰富的组合操作等。最后，我们将通过具体的案例来展示 CompletableFuture 在不同场景下的应用，帮助读者更好地理解和掌握这一并发编程核心知识点。
CompletableFuture 概念
CompletableFuture 是 Java 8 引入的一个用于异步编程的类，它提供了强大的异步执行和结果处理能力。在介绍 CompletableFuture 之前，我们先来回顾一下传统的异步编程模型。
传统的异步编程模型通常依赖于回调函数，即当一个异步操作完成时，会执行一个回调函数来处理结果。这种模式在处理多个异步操作时，代码会变得复杂且难以维护。而 CompletableFuture 则提供了一种更简洁、更易于理解的异步编程模型。
🎉 异步编程模型对比
| 传统异步编程模型 | CompletableFuture |
|---|---|
| 使用回调函数 | 使用链式调用 |
| 代码复杂，难以维护 | 代码简洁，易于理解 |
| 难以处理多个异步操作 | 易于处理多个异步操作 |
🎉 任务链式调用
CompletableFuture 提供了丰富的方法来构建任务链式调用，使得异步编程更加直观。以下是一些常用的链式调用方法：
thenApply：在当前异步操作完成后，应用一个函数来处理结果，并返回一个新的 CompletableFuture。thenAccept：在当前异步操作完成后，接受一个函数来处理结果，但不返回新的 CompletableFuture。thenRun：在当前异步操作完成后，执行一个无返回值的操作。
以下是一个使用 thenApply 的示例：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
future.thenApply(s -> "World " + s).thenAccept(System.out::println);
🎉 结果处理与异常处理
CompletableFuture 提供了多种方法来处理异步操作的结果和异常：
get：阻塞等待异步操作完成，并返回结果。join：与get类似，但可以指定超时时间。exceptionally：处理异步操作抛出的异常。handle：同时处理结果和异常。
以下是一个处理异常的示例：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
throw new RuntimeException("Error occurred");
}).exceptionally(ex -> {
System.out.println("Exception: " + ex.getMessage());
return "Fallback value";
}).thenAccept(System.out::println);
🎉 执行器配置与线程池的关联
CompletableFuture 可以与线程池关联，从而提高性能。以下是如何配置执行器：
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture.supplyAsync(() -> "Hello", executor).thenAccept(System.out::println);
🎉 与 Future 的对比
CompletableFuture 与 Future 类似，但 CompletableFuture 提供了更丰富的功能，如链式调用、结果处理和异常处理等。
🎉 与 FutureTask 的关联
CompletableFuture 是 FutureTask 的扩展，提供了更多的功能。
🎉 与回调函数的关系
CompletableFuture 可以替代回调函数，提供更简洁的异步编程模型。
🎉 与 Java 8 Stream API 的集成
CompletableFuture 可以与 Java 8 Stream API 集成，实现异步流操作。
🎉 应用场景
CompletableFuture 适用于需要处理多个异步操作的场景，如网络请求、文件读写、数据库操作等。
🎉 性能优势
CompletableFuture 提供了更简洁、更易于理解的异步编程模型，从而提高了开发效率和代码可维护性。
🎉 局限性
CompletableFuture 依赖于 Java 8，因此不支持旧版本的 Java。
🎉 最佳实践
- 使用链式调用构建异步任务链。
- 使用
exceptionally和handle处理异常。 - 配置合适的执行器以提高性能。
通过以上内容，我们可以看到 CompletableFuture 在异步编程方面具有强大的功能和优势。在实际项目中，合理运用 CompletableFuture 可以提高代码的可读性和可维护性，同时提高系统的性能。
🎉 CompletableFuture 优势
在 Java 并发编程领域，CompletableFuture 是一个革命性的改进，它提供了比传统的 Future 和 Callable 更加强大和灵活的异步编程模型。以下是对 CompletableFuture 优势的详细阐述：
📝 并发模型
相较于传统的线程池和 Future 模型，CompletableFuture 提供了一种更高级的并发模型。它允许你以声明式的方式编写异步代码，这使得代码更加简洁，易于理解和维护。
| 传统模型 | CompletableFuture |
|---|---|
| 需要显式地创建线程和线程池 | 内置线程池，无需显式创建 |
| 需要手动处理线程同步问题 | 提供内置的线程安全机制 |
| 异步操作之间缺乏直接关联 | 支持任务链式调用，易于管理异步操作 |
📝 任务链式调用
CompletableFuture 支持任务链式调用，这使得你可以轻松地将多个异步操作串联起来，形成一个复杂的异步流程。这种链式调用方式使得代码更加简洁，易于阅读和维护。
CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s -> "Hello, " + s)
.thenAccept(System.out::println);
📝 异步编程
CompletableFuture 提供了丰富的异步编程接口，如 supplyAsync、thenApply、thenAccept、thenRun、thenCompose 等，这些接口使得你可以轻松地实现复杂的异步逻辑。
📝 线程安全
CompletableFuture 内置了线程安全机制，这使得你无需担心在异步操作中手动处理线程同步问题。例如，你可以直接在 CompletableFuture 上调用 get() 方法来获取异步操作的结果，而无需担心线程安全问题。
📝 错误处理
CompletableFuture 提供了丰富的错误处理机制，如 exceptionally、handle、whenComplete 等，这些机制使得你可以轻松地处理异步操作中可能出现的异常。
CompletableFuture.supplyAsync(() -> "Hello")
.exceptionally(ex -> "Error: " + ex.getMessage())
.thenAccept(System.out::println);
📝 结果获取
CompletableFuture 提供了多种获取异步操作结果的方式，如 get()、join()、getNow() 等。这些方法使得你可以根据实际需求灵活地获取异步操作的结果。
📝 性能提升
CompletableFuture 内置了线程池，这使得你可以充分利用多核处理器的能力，从而提升程序的性能。
📝 代码简洁性
CompletableFuture 提供了丰富的异步编程接口，使得你可以以声明式的方式编写异步代码，从而提高代码的简洁性和可读性。
📝 与 Future 和 Callable 的比较
| Future | Callable | CompletableFuture |
|---|---|---|
| 只能获取异步操作的结果 | 只能执行异步操作，无法获取结果 | 支持获取异步操作的结果，支持任务链式调用，提供丰富的异步编程接口 |
| 线程安全机制较弱 | 线程安全机制较弱 | 内置线程安全机制，易于处理线程同步问题 |
总结来说，CompletableFuture 是 Java 并发编程领域的一项重要改进，它提供了更加强大、灵活和易于使用的异步编程模型。在实际项目中，合理运用 CompletableFuture 可以提高代码的简洁性、可读性和可维护性，同时提升程序的性能。
CompletableFuture：适用场景
在Java并发编程中，CompletableFuture 是一个强大的工具，它允许开发者以声明式的方式处理异步编程。下面，我将从多个维度详细阐述 CompletableFuture 的适用场景。
🎉 1. 任务分解与组合
CompletableFuture 非常适合于需要将一个大任务分解为多个子任务，并且需要等待所有子任务完成的情况。例如，在处理图像处理任务时，可以将图像分割成多个部分，每个部分由不同的线程进行处理，最后再将处理结果合并。
| 任务分解与组合场景 | 例子 |
|---|---|
| 图像处理 | 将图像分割成多个部分，分别处理每个部分，最后合并结果 |
| 数据处理 | 将大量数据分割成多个批次，分别处理每个批次，最后合并结果 |
🎉 2. 异步编程模式
CompletableFuture 支持多种异步编程模式，如 thenApply、thenAccept、thenRun 等，这些模式使得异步编程变得更加简单和直观。
| 异步编程模式 | 例子 |
|---|---|
| thenApply | 将一个异步操作的结果作为另一个异步操作的输入 |
| thenAccept | 接受一个异步操作的结果，但不返回任何值 |
| thenRun | 在异步操作完成后执行一个操作，但不依赖于其结果 |
🎉 3. 错误处理与异常管理
CompletableFuture 提供了丰富的异常处理机制，如 exceptionally、handle 等，使得异常处理更加灵活。
| 错误处理与异常管理场景 | 例子 |
|---|---|
| 异步任务失败 | 使用 exceptionally 处理异步任务失败的情况 |
| 异常传播 | 使用 handle 将异常传播到调用者 |
🎉 4. 线程安全与共享资源
CompletableFuture 内部使用线程池来执行异步任务，因此它本身是线程安全的。这使得在处理共享资源时，可以避免多线程并发问题。
| 线程安全与共享资源场景 | 例子 |
|---|---|
| 数据库操作 | 使用 CompletableFuture 异步执行数据库操作，确保线程安全 |
| 文件读写 | 使用 CompletableFuture 异步执行文件读写操作，避免多线程并发问题 |
🎉 5. 性能优化与调优
CompletableFuture 可以与 Java 中的其他并发工具（如 ExecutorService）结合使用，从而实现性能优化和调优。
| 性能优化与调优场景 | 例子 |
|---|---|
| 线程池配置 | 根据实际需求调整线程池配置，提高并发性能 |
| 异步任务优化 | 优化异步任务，减少任务执行时间，提高系统响应速度 |
🎉 6. 与其他并发工具对比
与传统的并发工具（如 ExecutorService、Future）相比，CompletableFuture 提供了更丰富的功能，使得异步编程更加简单和直观。
| 并发工具对比 | 优点 |
|---|---|
| ExecutorService | 功能强大，但使用复杂 |
| Future | 简单易用，但功能有限 |
| CompletableFuture | 功能丰富，使用简单 |
🎉 7. 实际应用案例
在实际项目中，CompletableFuture 可以应用于各种场景，如：
- 网络请求：异步发送 HTTP 请求，处理响应数据
- 数据库操作：异步执行数据库查询，处理查询结果
- 文件处理：异步读取、写入文件，处理文件数据
总之，CompletableFuture 是一个功能强大、易于使用的并发编程工具，适用于各种需要异步处理任务的场景。
🍊 并发编程核心知识点之 CompletableFuture：基本使用
在当今的软件开发领域，随着应用复杂性的不断增加，对系统性能的要求也越来越高。特别是在处理大量数据或执行耗时操作时，如何有效地利用系统资源，提高程序的执行效率，成为了一个关键问题。一个典型的场景是，在一个在线交易系统中，用户发起的查询请求需要同时访问数据库、调用外部API以及进行复杂的业务逻辑处理。如果这些操作是顺序执行的，那么整个请求的处理时间将会非常长，用户体验将大打折扣。
为了解决这个问题，我们需要引入并发编程的概念。在Java中，CompletableFuture 是一个强大的工具，它允许开发者以声明式的方式编写异步代码，从而简化并发编程的复杂性。CompletableFuture 提供了一种简洁的方式来处理异步操作，它能够将多个异步任务组合起来，使得异步编程变得更加直观和易于管理。
介绍 CompletableFuture 的基本使用之所以重要，是因为它能够帮助我们：
- 简化异步编程：通过
CompletableFuture，开发者可以避免编写复杂的回调函数或使用线程池，从而简化异步编程的复杂性。 - 提高代码可读性：
CompletableFuture提供了一系列的链式调用方法，使得异步代码的执行流程更加清晰，易于理解和维护。 - 提升系统性能：通过并发执行任务，
CompletableFuture能够显著提高系统的响应速度和吞吐量。
接下来，我们将深入探讨 CompletableFuture 的几个关键方面：
- 创建
CompletableFuture：介绍如何创建一个空的CompletableFuture对象，以及如何使用supplyAsync方法启动一个异步任务。 - 执行异步任务：讲解如何使用
thenApply、thenAccept和thenRun等方法来处理异步任务的结果，以及如何将多个异步任务链式调用。 - 获取结果：讨论如何使用
get、join和await等方法来获取异步任务的结果，以及如何处理可能出现的异常情况。
通过这些内容，读者将能够全面理解 CompletableFuture 的基本使用，并能够在实际项目中有效地应用这一工具。
🎉 CompletableFuture 创建方式
在 Java 中，CompletableFuture 是一个用于异步编程的类，它提供了创建异步任务、执行任务、处理结果和异常的丰富功能。下面，我们将详细探讨 CompletableFuture 的创建方式。
📝 创建方式对比
| 创建方式 | 描述 | 代码示例 |
|---|---|---|
| 构造器 | 直接使用 CompletableFuture 类的构造器创建。 |
```java |
new CompletableFuture<>();
| 静态方法 | 使用 `CompletableFuture` 类提供的静态方法创建。 | ```java
CompletableFuture.supplyAsync(() -> "Hello, World!");
``` |
| 异步方法 | 在其他异步方法中返回 `CompletableFuture` 对象。 | ```java
public CompletableFuture<String> asyncMethod() {
return CompletableFuture.supplyAsync(() -> "Hello, World!");
}
``` |
#### 📝 静态方法详解
静态方法提供了多种创建 `CompletableFuture` 的方式，以下是一些常用的静态方法：
- `supplyAsync(Runnable supplier)`：创建一个异步任务，该任务执行 `Runnable` 提供的操作。
- `supplyAsync(Supplier<U> supplier)`：创建一个异步任务，该任务执行 `Supplier` 提供的操作，并返回结果。
- `runAsync(Runnable runner)`：创建一个异步任务，该任务执行 `Runnable` 提供的操作，不返回结果。
- `completedFuture(T value)`：创建一个已经完成的 `CompletableFuture`，其结果为 `value`。
### 🎉 执行方法
创建 `CompletableFuture` 后，我们需要执行它以获取结果。以下是一些常用的执行方法：
- `get()`：同步等待 `CompletableFuture` 完成，并返回结果。
- `join()`：与 `get()` 类似，但返回类型为泛型类型 `T`。
- `thenApply(Function<? super T, ? extends U> fn)`：在 `CompletableFuture` 完成（成功或失败）后，应用 `Function` 函数。
- `thenAccept(Consumer<? super T> action)`：在 `CompletableFuture` 完成（成功或失败）后，执行 `Consumer` 操作。
### 🎉 异步编程模型
`CompletableFuture` 提供了一种强大的异步编程模型，允许我们在异步任务中执行复杂的逻辑。以下是一些关键概念：
- **任务链式调用**：通过 `thenApply`、`thenAccept` 等方法，可以将多个异步任务连接成一个任务链。
- **异常处理**：`CompletableFuture` 支持异常处理，可以通过 `exceptionally` 方法处理异常。
- **结果获取**：通过 `get` 或 `join` 方法获取异步任务的结果。
### 🎉 实际应用案例
以下是一个使用 `CompletableFuture` 的实际应用案例，该案例模拟了从数据库中查询用户信息的过程：
```java
public CompletableFuture<User> getUserInfo(String userId) {
return CompletableFuture.supplyAsync(() -> {
// 模拟数据库查询
Thread.sleep(1000);
return new User(userId, "John Doe");
});
}
public void processUserInfo(String userId) {
getUserInfo(userId)
.thenApply(user -> {
// 处理用户信息
return user;
})
.thenAccept(user -> {
// 输出用户信息
System.out.println("User: " + user);
})
.exceptionally(ex -> {
// 异常处理
System.out.println("Error: " + ex.getMessage());
return null;
});
}
在这个例子中，我们首先使用 supplyAsync 方法创建一个异步任务来查询用户信息。然后，我们使用 thenApply 和 thenAccept 方法来处理和输出用户信息。最后，我们使用 exceptionally 方法来处理可能发生的异常。
🎉 CompletableFuture 异步任务执行
在 Java 中，CompletableFuture 是一个强大的工具，用于执行异步任务。它提供了丰富的 API 来处理异步编程中的各种场景。下面，我们将从多个维度来详细探讨 CompletableFuture。
📝 线程模型
CompletableFuture 使用的是非阻塞的线程模型。这意味着它不会占用一个线程来执行任务，而是使用线程池来处理异步任务。这种模型使得 CompletableFuture 能够高效地处理大量并发任务。
| 特点 | 说明 |
|---|---|
| 非阻塞 | 不占用线程 |
| 线程池 | 使用线程池处理任务 |
📝 任务链式调用
CompletableFuture 支持链式调用，这使得异步任务之间的依赖关系变得非常清晰。你可以通过 thenApply、thenAccept、thenRun 等方法来连接多个异步任务。
CompletableFuture.supplyAsync(() -> "Hello")
.thenApply(s -> "World " + s)
.thenAccept(System.out::println);
📝 异常处理
CompletableFuture 提供了丰富的异常处理机制。你可以使用 exceptionally 方法来处理异常，或者使用 handle 方法来同时处理成功和异常的情况。
CompletableFuture.supplyAsync(() -> {
throw new RuntimeException("Error");
}).exceptionally(ex -> {
System.out.println("Exception: " + ex.getMessage());
return "Fallback";
}).thenAccept(System.out::println);
📝 结果获取
CompletableFuture 提供了多种方法来获取异步任务的结果，如 get、join 等。这些方法会阻塞当前线程，直到异步任务完成。
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Result");
String result = future.get();
System.out.println(result);
📝 执行策略
CompletableFuture 允许你指定执行策略。你可以使用 CompletableFuture.runAsync 和 CompletableFuture.supplyAsync 方法来指定不同的执行策略。
| 方法 | 说明 |
|---|---|
| runAsync | 无返回值 |
| supplyAsync | 有返回值 |
📝 与 Future 和 Callable 的关系
CompletableFuture 是 Future 和 Callable 的升级版。它提供了更丰富的 API 来处理异步任务。
| 对比 | Future | CompletableFuture |
|---|---|---|
| 异常处理 | 需要手动处理 | 内置异常处理机制 |
| 链式调用 | 不支持 | 支持链式调用 |
📝 与线程池的集成
CompletableFuture 可以与线程池集成，使得异步任务可以高效地执行。
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture.supplyAsync(() -> "Result", executor).thenAccept(System.out::println);
📝 与 Spring 集成
CompletableFuture 可以与 Spring 集成，使得异步任务可以与 Spring 中的其他组件无缝协作。
@Service
public class AsyncService {
@Async
public CompletableFuture<String> asyncMethod() {
return CompletableFuture.supplyAsync(() -> "Result");
}
}
📝 与 Reactor 的比较
CompletableFuture 和 Reactor 都用于异步编程，但它们在实现上有所不同。CompletableFuture 是基于 Future 的，而 Reactor 是基于 RxJava 的。
| 对比 | CompletableFuture | Reactor |
|---|---|---|
| 实现方式 | 基于 Future | 基于 RxJava |
| 生态 | 较小 | 较大 |
📝 应用场景
CompletableFuture 适用于需要处理大量并发任务的场景，如网络请求、数据库操作等。
最低0.47元/天 解锁文章
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
