使用 CompletableFuture 实现异步编程

# 1. 理解 CompletableFuture 异步编程

## 1.1 CompletableFuture 简介
在现代的应用开发中，异步编程已经成为一种常见的技术手段。CompletableFuture 是 Java 8 引入的一个强大的异步编程工具，提供了一种简洁方便的方式来处理异步任务和操作的结果。它可以在执行一个耗时操作时，不会阻塞其他线程，并且可以在任务完成后执行一系列的回调操作。

## 1.2 异步编程的优势
异步编程可以提高程序的响应性和并发能力，避免阻塞线程的情况，尤其在处理一些耗时的 I/O 操作或计算密集型任务时，可以显著提升应用的性能。使用 CompletableFuture 可以更加方便地进行异步编程，避免了传统线程操作的繁琐和复杂性。

## 1.3 CompletableFuture 与传统线程操作的区别
相比传统的线程操作，CompletableFuture 提供了更加强大和灵活的功能：
- CompletableFuture 可以支持异步任务的链式调用，避免了回调地狱的问题。
- CompletableFuture 提供了丰富的组合方法，可以方便地串行、并行地执行异步任务，并且在任务完成后可以进行结果的合并或转换操作。
- CompletableFuture 支持异常的处理和超时设置，可以更好地控制任务的执行流程。

下一章我们将深入研究 CompletableFuture 的基本使用。

# 2. 基本使用

### 2.1 创建 CompletableFuture 对象

在 CompletableFuture 中，可以通过以下几种方式来创建 CompletableFuture 对象：

- `CompletableFuture.runAsync()`：创建一个不返回结果的异步任务
- `CompletableFuture.supplyAsync()`：创建一个可以返回结果的异步任务
- `CompletableFuture.completedFuture()`：创建一个已经完成的 CompletableFuture 对象

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class CompletableFutureBasic {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 示例1：创建一个不返回结果的异步任务
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            // 异步任务的具体执行逻辑
            System.out.println("任务一正在执行...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务一执行完毕！");
        });

        // 示例2：创建一个可以返回结果的异步任务
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            // 异步任务的具体执行逻辑
            System.out.println("任务二正在执行...");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务二执行完毕！");
            return "任务二的结果";
        });

        // 示例3：创建一个已经完成的 CompletableFuture 对象
        CompletableFuture<String> future3 = CompletableFuture.completedFuture("已完成的 CompletableFuture");

        // 等待异步任务执行完毕并输出结果
        future1.get();
        future2.get();
        System.out.println(future3.get());
    }
}

代码说明：
- 示例1：通过 `CompletableFuture.runAsync()` 创建了一个不返回结果的异步任务，并在其中模拟了一个耗时操作。
- 示例2：通过 `CompletableFuture.supplyAsync()` 创建了一个可以返回结果的异步任务，并在其中模拟了一个耗时操作，并返回了一个结果。
- 示例3：通过 `CompletableFuture.completedFuture()` 创建了一个已经完成的 CompletableFuture 对象。

### 2.2 异步任务的执行与获取结果

在 CompletableFuture 中，异步任务的执行与获取结果可以通过以下几个方法来实现：

- `CompletableFuture.get()`：阻塞等待异步任务的完成，并获取结果
- `CompletableFuture.join()`：等待异步任务的完成，并获取结果（与 get() 方法的区别在于不抛出异常）
- `CompletableFuture.thenApply()`：对异步任务的结果进行转换处理
- `CompletableFuture.thenAccept()`：对异步任务的结果进行消费处理
- `CompletableFuture.thenRun()`：在异步任务完成后执行额外的操作

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class CompletableFutureExecution {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 示例1：获取异步任务的结果
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务一正在执行...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务一执行完毕！");
            return "任务一的结果";
        });

        System.out.println("任务一的结果为：" + future1.get());

        // 示例2：对异步任务的结果进行转换处理
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务二正在执行...");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务二执行完毕！");
            return "任务二的结果";
        });

        CompletableFuture<Integer> transformedFuture = future2.thenApply(result -> result.length());
        System.out.println("任务二的长度为：" + transformedFuture.get());

        // 示例3：对异步任务的结果进行消费处理
        CompletableFuture<Void> future3 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务三正在执行...");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务三执行完毕！");
            return "任务三的结果";
        });

        future3.thenAccept(result -> System.out.println("任务三的结果为：" + result));

        // 示例4：在异步任务完成后执行额外的操作
        CompletableFuture<Void> future4 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务四正在执行...");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务四执行完毕！");
            return null;
        });

        future4.thenRun(() -> System.out.println("任务四执行完毕后的操作"));
    }
}

代码说明：
- 示例1：通过 `CompletableFuture.get()` 来阻塞等待异步任务的完成，并获取结果。
- 示例2：通过 `CompletableFuture.thenApply()` 对异步任务的结果进行转换处理，返回一个新的 CompletableFuture 对象。
- 示例3：通过 `CompletableFuture.thenAccept()` 对异步任务的结果进行消费处理，不返回新的 CompletableFuture 对象。
- 示例4：通过 `CompletableFuture.thenRun()` 在异步任务完成后执行额外的操作，不操作结果。

### 2.3 异常处理与超时设置

在 CompletableFuture 中，可以通过以下方法来处理异步任务的异常和设置超时时间：

- `CompletableFuture.handle()`：处理异步任务的运行结果（包括正常结果和异常结果）
- `CompletableFuture.exceptionally()`：处理异步任务的异常结果
- `CompletableFuture.whenComplete()`：执行操作后处理结果（包括正常结果和异常结果）
- `CompletableFuture.completeExceptionally()`：手动抛出异常
- `CompletableFuture.completeOnTimeout()`：在指定时间内完成，否则返回默认值

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CompletableFutureException {

    public static void main(String[] args) throws ExecutionException, InterruptedException, TimeoutException {
        // 示例1：处理异步任务的运行结果（包括正常结果和异常结果）
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 模拟抛出异常
            throw new RuntimeException("任务一发生异常");
        });

        String result1 = future1.handle((result, exception) -> {
            if (exception != null) {
                return "处理异常：" + exception.getMessage();
            }
            return "正常结果：" + result;
        }).get();
        System.out.println(result1);

        // 示例2：处理异步任务的异常结果
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 模拟抛出异常
            throw new NullPointerException("任务二发生异常");
        });

        String result2 = future2.exceptionally(exception -> "处理异常：" + exception.getMessage()).get();
        System.out.println(result2);

        // 示例3：执行操作后处理结果（包括正常结果和异常结果）
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务三的结果";
        });

        CompletableFuture<Void> whenCompleteFuture = future3.whenComplete((result, exception) -> {
            if (exception != null) {
                System.out.println("处理异常：" + exception.getMessage());
            } else {
                System.out.println("任务三的结果为：" + result);
            }
        });
        whenCompleteFuture.get();

        // 示例4：手动抛出异常
        CompletableFuture<String> future4 = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("任务四发生异常");
        });

        try {
            String result4 = future4.get();
        } catch (Exception e) {
            future4.completeExceptionally(e);
        }

        // 示例5：超时设置
        CompletableFuture<String> future5 = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "任务五的结果";
        });

        String result5 = future5.orTimeout(2, TimeUnit.SECONDS).exceptionally(exception -> "超时异常：" + exception.getMessage()).get();
        System.out.println(result5);
    }
}

代码说明：
- 示例1：通过 `CompletableFuture.handle()` 来处理异步任务的运行结果（包括正常结果和异常结果）。
- 示例2：通过 `CompletableFuture.exceptionally()` 来处理异步任务的异常结果。
- 示例3：通过 `CompletableFuture.whenComplete()` 来执行操作后处理结果（包括正常结果和异常结果）。
- 示例4：通过 `CompletableFuture.completeExceptionally()` 来手动抛出异常。
- 示例5：通过 `CompletableFuture.orTimeout()` 来设置超时时间，如果超时则返回一个默认值。

通过以上示例，我们了解了 CompletableFuture 的基本使用方法。下一章节，我们将介绍如何组合多个 CompletableFuture 实现复杂的异步编程需求。

# 3. 组合多个 CompletableFuture

在本章中，我们将学习如何使用 CompletableFuture 来组合多个异步任务，以及探讨 CompletableFuture 组合的最佳实践。

#### 3.1 thenCombine 与 thenCompose 方法的使用

首先，让我们了解一下 `thenCombine` 和 `thenCompose` 方法的使用。

##### 3.1.1 使用 thenCombine 合并两个异步任务的结果

public void thenCombineExample() {
    CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
    CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

    CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + " " + result2);

    combinedFuture.thenAccept(System.out::println);
}

在上面的示例中，我们创建了两个 CompletableFuture 对象，分别返回字符串 "Hello" 和 "World"。然后，通过 `thenCombine` 方法将这两个异步任务的结果进行合并，并输出 "Hello World"。

##### 3.1.2 使用 thenCompose 组合两个异步任务的执行

public void thenComposeExample() {
    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
    CompletableFuture<String> composedFuture = future.thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " World"));
    composedFuture.thenAccept(System.out::println);
}

上面的示例中，我们首先创建了一个 CompletableFuture 对象，返回字符串 "Hello"。然后通过 `thenCompose` 方法，将当前 CompletableFuture 的结果作为参数传递给另一个 CompletableFuture，并在其基础上进行进一步的异步处理。

#### 3.2 CompletableFuture 组合的最佳实践

在实际项目中，组合多个 CompletableFuture 时，我们通常会面临一些最佳实践的选择，比如如何构建有序的任务流水线、如何处理异常等。下面是一些组合 CompletableFuture 的最佳实践：

- 使用 thenApply、thenCompose、thenCombine 等方法使得任务流水线清晰可读。
- 在完成多个 CompletableFuture 合并时，使用 `thenCompose` 而不是 `thenCombine`，前者可以更好地处理多个异步任务依赖关系。
- 对于异常处理，可以使用 `handle` 方法来处理异常情况，以保证异常不会中断整个流程。

通过合理的异步任务组合，可以提高系统的性能和吞吐量，同时保持代码的可读性和可维护性。

# 4. 并发与并行操作

在本章中，我们将深入探讨如何使用 CompletableFuture 实现并发和并行操作。我们将讨论如何利用 CompletableFuture 提高程序的性能，并探讨一些与并发相关的最佳实践。

#### 4.1 使用 CompletableFuture 实现并行处理

首先，让我们来看一下如何使用 CompletableFuture 实现并行处理。在传统的编程模型中，实现并行处理通常需要编写复杂的线程管理代码，而 CompletableFuture 则大大简化了这一过程。下面是一个简单的示例，演示了如何同时执行两个耗时的任务并获取它们的结果。

import java.util.concurrent.CompletableFuture;

public class ParallelProcessingExample {
    public static void main(String[] args) {
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            // 模拟一个耗时的任务
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task 1 result";
        });

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            // 模拟另一个耗时的任务
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task 2 result";
        });

        CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(task1, task2);

        combinedFuture.thenRun(() -> {
            String result1 = task1.join();
            String result2 = task2.join();
            System.out.println("Combined Result: " + result1 + " and " + result2);
        }).join();
    }
}

在这个示例中，我们使用 `CompletableFuture.supplyAsync` 方法创建了两个并行执行的异步任务，并通过 `CompletableFuture.allOf` 方法将它们组合在一起。最后，通过 `thenRun` 方法等待两个任务都执行完成后，进行结果的合并和输出。

#### 4.2 CompletableFuture 与并发性能优化

除了简单的并行处理外，CompletableFuture 还提供了一些方法来优化并发性能。其中，`thenApplyAsync` 和 `thenCombineAsync` 等方法可以让我们更好地利用多核处理器，实现任务的并行化执行。

import java.util.concurrent.CompletableFuture;

public class ConcurrentPerformanceOptimization {
    public static void main(String[] args) {
        CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> {
            // 模拟一个耗时的任务
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task 1 result";
        });

        CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> {
            // 模拟另一个耗时的任务
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Task 2 result";
        });

        CompletableFuture<String> combinedFuture = task1
                .thenCombine(task2, (result1, result2) -> "Combined Result: " + result1 + " and " + result2);

        System.out.println(combinedFuture.join());
    }
}

在这个示例中，我们使用了 `thenCombine` 方法将两个异步任务的结果进行合并，并在合并完成后立即返回结果。这种方式可以更好地利用并行执行的特性，提高程序的性能。

通过这些方法，我们可以灵活地利用 CompletableFuture 来实现并发和并行操作，从而提升程序的性能和效率。

# 5. 【与其他异步编程框架的对比】

## 5.1 与 Future/Callable 的对比

在 Java 中，Future 接口与 Callable 接口是实现异步编程的两个主要接口。与 CompletableFuture 相比，它们的功能相对较弱，以下是它们的对比：

- CompletableFuture 可以通过 thenApply、thenCompose 等方法连接多个异步任务，形成任务链，而 Future/Callable 需要使用代码嵌套或者使用额外的工具类来实现任务的串联。

- CompletableFuture 提供了丰富的方法进行异常处理，可以通过 exceptionally 和 handle 方法来处理异步任务中的异常情况，而 Future/Callable 需要手动捕获异常并进行处理。

- CompletableFuture 可以通过 thenCombine 和 thenAcceptBoth 等方法组合多个异步任务的结果，而 Future/Callable 需要通过其他方式实现。

- CompletableFuture 支持超时设置，可以使用 orTimeout 和 completeOnTimeout 方法来设置异步任务的超时时间，而 Future/Callable 则需要自己通过定时器或其他方式实现。

虽然 CompletableFuture 在功能上更加强大，但是 Future/Callable 也有自己的优势，比如它们在 JDK 1.5 就已经存在，更加稳定可靠，而且在一些特定的场景下仍然可以发挥重要作用。

## 5.2 与 RxJava、Guava 等框架的对比

除了 Future/Callable 外，还有一些其他的异步编程框架，比如 RxJava、Guava 等，它们与 CompletableFuture 相比有以下特点：

- RxJava 是一个基于观察者模式的异步编程框架，可以通过 Observable、Flowable 等类来实现异步任务的订阅与响应，比 CompletableFuture 更加灵活，可以实现更复杂的异步场景，但是使用起来也更加复杂。

- Guava 提供的 ListenableFuture 类似于 CompletableFuture，也是实现异步编程的工具类，它不如 CompletableFuture 功能丰富，但是比 Future/Callable 更易于使用。

相比之下，CompletableFuture 在 JDK 中自带，使用较为简单，并且已经被广泛应用于实际项目中。但是在一些特定的场景下，选择其他框架也是一种不错的选择。

通过与其他异步编程框架的对比，我们可以根据具体的需求和项目特点选择合适的框架，以提升代码的可读性和性能。

本章节对 CompletableFuture 与其他异步编程框架进行了对比分析，希望能够帮助读者更好地了解 CompletableFuture 的优势和不足，并在实际应用中进行合理选择。

# 6. 案例分析与实战应用

在本章中，我们将深入探讨实际项目中 CompletableFuture 的应用案例，并介绍如何在项目中合理利用 CompletableFuture 进行异步编程。我们将通过具体的示例来展示 CompletableFuture 在实战中的应用，以便读者更好地理解并运用 CompletableFuture。

#### 6.1 实际项目中的 CompletableFuture 应用案例
我们将从实际项目中选取一个常见的场景，介绍如何使用 CompletableFuture 来解决问题。通过这个案例，读者可以更好地理解 CompletableFuture 的实际应用。

##### 场景描述
假设在一个电商平台的订单处理系统中，存在以下几个异步任务：
- 异步获取订单信息
- 异步获取用户信息
- 异步获取商品信息
- 异步生成订单处理日志

在传统的同步处理方式中，这些任务需要依次执行，会导致整体处理时间较长。而使用 CompletableFuture 可以并发执行这些异步任务，大大缩短整体处理时间。

##### 代码示例

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) {
        CompletableFuture<String> orderInfoFuture = CompletableFuture.supplyAsync(() -> getOrderInfo());
        CompletableFuture<String> userInfoFuture = CompletableFuture.supplyAsync(() -> getUserInfo());
        CompletableFuture<String> productInfoFuture = CompletableFuture.supplyAsync(() -> getProductInfo());
        CompletableFuture<String> logInfoFuture = orderInfoFuture.thenCombine(userInfoFuture, (order, user) -> generateLog(order, user))
                .thenCombine(productInfoFuture, (log, product) -> generateLog(log, product));
        String result = logInfoFuture.join();
        System.out.println("处理结果：" + result);
    }
    private static String getOrderInfo() {
        // 异步获取订单信息的具体实现
        return "订单信息";
    }
    private static String getUserInfo() {
        // 异步获取用户信息的具体实现
        return "用户信息";
    }
    private static String getProductInfo() {
        // 异步获取商品信息的具体实现
        return "商品信息";
    }
    private static String generateLog(String info1, String info2) {
        // 异步生成日志的具体实现
        return "生成日志：" + info1 + ", " + info2;
    }
}

##### 代码说明
- 首先，我们使用 CompletableFuture.supplyAsync() 方法创建了四个异步任务，分别用于获取订单信息、用户信息、商品信息以及生成日志。
- 然后通过 thenCombine() 方法将订单信息与用户信息、生成日志与商品信息组合，实现了相关任务之间的关联和并发执行。
- 最后，通过 join() 方法等待所有任务执行完成，并获取最终的处理结果。

#### 6.2 如何在项目中合理利用 CompletableFuture 进行异步编程
在实际项目中，合理利用 CompletableFuture 进行异步编程可以大大提高系统的性能和并发处理能力。但是在使用过程中，需要注意一些细节和注意事项：

##### 最佳实践
- 合理划分任务粒度：将任务划分为合适的粒度，避免出现任务过于庞大或过于细小的情况。
- 注意异常处理：及时处理任务执行过程中的异常，避免异常信息丢失和对系统造成影响。
- 调整线程池参数：根据实际业务场景调整线程池的大小、超时时间等参数，以优化系统性能。
- 避免滥用并行流操作：过多使用并行流可能会导致系统资源浪费，需要注意合理使用。

通过合理使用 CompletableFuture，可以大大提高系统的并发能力和性能，同时也可以提升开发效率。

通过本章的案例分析和最佳实践，相信读者已经对 CompletableFuture 在实际项目中的应用有了更深入的理解，同时也对如何合理利用 CompletableFuture 进行异步编程有了更清晰的认识。希