Java异步编程模型：掌握CompletableFuture与Reactive Streams的秘诀


参考资源链接：[Java核心技术：深入解析与实战指南(英文原版第12版)](https://wenku.csdn.net/doc/11tbc1mpry?spm=1055.2635.3001.10343)
# 1. Java异步编程模型概述

在现代软件开发中，提高应用的性能和响应速度是至关重要的。Java作为一种成熟稳定的编程语言，提供了强大的异步编程模型来支持开发者实现高效的应用构建。本章将概览Java异步编程模型的基础知识，为读者建立一个清晰的理解框架。

Java的异步编程模型不仅仅是一个简单的概念，它涵盖了从多线程到并发工具，再到响应式编程范式的一系列技术栈。随着JDK的发展，Java提供了更为丰富和灵活的方式来处理异步任务，其中最重要的一部分就是CompletableFuture和Reactive Streams。

## 1.1 Java并发模型的演变

Java的并发模型已经从早期的简单线程模型演进到了一个更加全面和强大的系统。在JDK 1.5版本中引入的java.util.concurrent包，为开发者提供了更高级的并发工具，包括Executor框架、锁和同步器等。而随着响应式编程的兴起，Java 9中引入的Reactive Streams API更是为异步数据处理和非阻塞背压提供了标准化的解决方案。

## 1.2 并发与并行的区别

在开始深入探讨之前，明确并发（Concurrency）和并行（Parallelism）的区别是十分必要的。并发是指同时进行多个任务，但这些任务并不一定同时运行，它们可能在不同的时间点上共享CPU资源；而并行则是指在真正意义上的同时执行多个任务，这通常需要多核CPU来实现。

理解并发和并行的区别对于设计高效的异步程序至关重要，因为不同的应用场景需要不同的处理策略。例如，在I/O密集型应用中，由于大部分时间都在等待数据的读写，因此利用异步I/O可以显著提高程序的效率；而在计算密集型应用中，多核CPU的并行处理能力则可以显著缩短任务的完成时间。

以上是对Java异步编程模型的基本概述，它为后续深入探讨CompletableFuture和Reactive Streams等具体技术打下了基础。接下来，我们将深入分析CompletableFuture的基础概念和高级特性，并在实践中展示它的强大能力。

# 2. 深入理解CompletableFuture

## 2.1 CompletableFuture的基础概念

### 2.1.1 异步任务的创建与执行

在Java中，`CompletableFuture` 是一个能够实现异步编程的类，它提供了强大的功能来处理异步计算结果。创建一个 `CompletableFuture` 实例非常简单，可以通过多种方式来初始化，例如使用无参数的构造函数，或者通过提供一个`Runnable`或`Callable`来创建。

// 通过无参数构造函数创建一个CompletableFuture
CompletableFuture<Void> future = new CompletableFuture<>();

// 使用Runnable，不会返回计算结果
CompletableFuture<Void> voidFuture = CompletableFuture.runAsync(() -> {
    // 异步执行任务
});

// 使用Callable，会返回计算结果
CompletableFuture<Integer> resultFuture = CompletableFuture.supplyAsync(() -> {
    // 异步执行任务并返回结果
    return 42; // 模拟返回结果
});

在上述代码中，`runAsync` 方法会启动一个异步任务，该任务没有返回值（`Void`），而 `supplyAsync` 方法会启动一个返回结果的异步任务。它们都接受 `Runnable` 或 `Callable` 作为参数，可以传递一个任务来执行。`CompletableFuture` 还可以链式调用其他方法来进一步处理异步结果。

### 2.1.2 结果的获取与异步处理

在异步任务完成时，我们通常需要获取其结果。`CompletableFuture` 提供了多种方法来处理异步结果。以下是常见的几种方法：

// 获取异步计算结果，会阻塞等待
Integer result = resultFuture.get();

// 使用thenApply来转换结果
Integer transformedResult = resultFuture.thenApply(r -> r * 2).get();

// 使用thenAccept来消费结果
resultFuture.thenAccept(result -> System.out.println("Result is: " + result));

// 使用thenRun来运行某些操作，它不接收结果参数
resultFuture.thenRun(() -> System.out.println("Task completed"));

`get()` 方法用于阻塞调用线程直到异步任务完成并获取其结果。`thenApply` 方法可以对结果进行转换，`thenAccept` 方法可以对结果进行消费，而 `thenRun` 方法可以执行一些不依赖于异步任务结果的操作。

## 2.2 CompletableFuture的高级特性

### 2.2.1 组合异步任务

有时候我们需要按照一定顺序执行多个异步任务，并在它们之间传递结果。`CompletableFuture` 提供了 `thenCompose` 和 `thenCombine` 方法来实现这一需求。

// 创建两个异步任务
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 42);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 84);

// 使用thenCompose方法组合两个异步任务
CompletableFuture<String> combinedFuture = future1.thenCompose(result1 -> {
    // 在这里可以根据第一个任务的结果继续创建第二个任务
    return future2.thenApply(result2 -> result1 + result2 + " is the answer.");
});

// 使用thenCombine方法并行组合两个异步任务
CompletableFuture<String> combinedFuture2 = future1.thenCombine(future2, (result1, result2) -> result1 + " and " + result2 + " is great.");

// 获取组合任务的结果
System.out.println("Combined Result: " + combinedFuture.get());
System.out.println("Combined Result 2: " + combinedFuture2.get());

`thenCompose` 方法用于在第一个异步任务完成后，根据其结果创建并执行第二个异步任务。`thenCombine` 方法则允许同时执行两个异步任务，并在它们都完成后执行一个合并操作。

### 2.2.2 异步任务的错误处理

在异步编程中，错误处理是不可或缺的一环。`CompletableFuture` 提供了 `exceptionally` 和 `handle` 方法来处理异步任务中可能出现的异常。

// 创建一个可能抛出异常的异步任务
CompletableFuture<String> futureWithException = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Something went wrong");
});

// 使用exceptionally方法处理异常
CompletableFuture<String> handleException = futureWithException.exceptionally(ex -> {
    System.out.println("Exception occurred: " + ex.getMessage());
    return "Error has been handled";
});

// 使用handle方法同时处理结果和异常
CompletableFuture<String> handleResultAndException = futureWithException.handle((result, ex) -> {
    if (ex != null) {
        System.out.println("Exception occurred: " + ex.getMessage());
        return "Error has been handled";
    }
    return result; // 或者根据结果做处理
});

// 获取错误处理后的结果
System.out.println(handleException.get());
System.out.println(handleResultAndException.get());

`exceptionally` 方法仅用于处理异常情况，而 `handle` 方法既可以处理结果，也可以处理异常。`handle` 方法接受两个参数：第一个参数是结果，第二个参数是可能发生的异常。无论结果是否成功，都可以在这里进行相应的处理。

### 2.2.3 自定义线程池和调度器

`CompletableFuture` 可以使用自定义的线程池来优化性能，以适应不同的业务场景。默认情况下，它使用的是 ForkJoinPool 的公共线程池，但我们可以传入自己的 `Executor` 来控制线程池的行为。

// 创建自定义线程池
Executor customExecutor = Executors.newFixedThreadPool(10);

// 使用自定义线程池执行异步任务
CompletableFuture<Void> customExecutorFuture = CompletableFuture.runAsync(() -> {
    // 使用自定义线程池执行的代码
}, customExecutor);

// 自定义调度器
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(5);
ScheduledFuture<?> scheduleFuture = scheduler.schedule(() -> {
    // 在指定延迟后执行的任务
}, 10, TimeUnit.SECONDS);

// 关闭调度器
scheduler.shutdown();

在这段代码中，我们创建了一个包含固定数量线程的自定义线程池，并将它传递给了 `runAsync` 方法。自定义的线程池可以根据需要进行扩展，例如，对任务进行隔离、设置不同的优先级等。对于需要定期执行的任务，可以使用