CompletableFuture 的使用

`CompletableFuture`是Java 8中引入的一个特性，它提供了一种异步编程模型，使得编写并处理并发、非阻塞和链式操作变得更加方便。`CompletableFuture`的主要用途在于解决回调地狱（Callback Hell）问题，以及简化基于Promise的异步编程。

以下是`CompletableFuture`的一些关键点：

1. **创建**：你可以直接从`FutureTask`、` suppliers`或现有的`CompletableFuture`实例开始创建新的`CompletableFuture`。

2. **链式调用**：通过`thenApply`, `thenAccept`, `thenCompose`等方法，可以将多个操作链接起来形成一条任务链，每个操作都在前一个操作完成之后执行。

3. **异步计算**：`supplyAsync`用于在单独线程上执行提供的函数，并返回一个`CompletableFuture`。

4. **异常处理**：`exceptionally`方法用于处理可能出现的异常，`handle`则允许你在某个阶段替换或恢复结果。

5. **等待完成**：`join`方法可以使当前线程等待`CompletableFuture`的结果，而`get`方法会阻塞直到结果可用。

6. **组合`CompletableFutures`**：可以使用`thenCombine`、`allOf`和`anyOf`等方法对多个`CompletableFuture`同步操作。

相关问题

completablefuture使用

CompletableFuture 是 Java 8 中新增的一种异步编程工具。

示例:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello";
}).thenApply(s -> s + " World");

System.out.println(future.get()); // 输出 "Hello World"

这个示例中，supplyAsync 方法用于异步执行一个任务，并返回一个 CompletableFuture 对象。thenApply 方法用于对上一步的结果进行处理，并返回一个新的 CompletableFuture。get 方法用于获取最终的结果。

另一个例子：

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

CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + s2);

System.out.println(combinedFuture.get()); // 输出 "Hello World"

这个例子中，使用 thenCombine 方法将两个 CompletableFuture 对象组合起来，并返回一个新的 CompletableFuture 对象。

还有其他的方法可以实现类似的操作,如: thenAccept,thenRun,exceptionally等等。

CompletableFuture 使用案例

`CompletableFuture`是Java 8中引入的一个强大的异步编程工具，它提供了非阻塞的、线程安全的和可组合的未来（future）对象，用于处理并发任务的结果。它主要用在需要异步计算并且需要处理计算结果的地方，如网络请求、数据库操作或复杂的任务序列。

一个典型的使用案例可能是从多个源获取数据并合并结果：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {

    public static void main(String[] args) {
        CompletableFuture<String> future1 = fetchFromAPI("url1");
        CompletableFuture<String> future2 = fetchFromAPI("url2");
        CompletableFuture<String> future3 = fetchFromDatabase("query1");

        // 将这些future组合成一个新的future，当所有原future都完成时，结果才会完成
        CompletableFuture<String[]> combinedFuture = CompletableFuture.allOf(future1, future2, future3)
                .thenApply(Arrays::asList);

        // 当所有数据都获取到后，调用thenApply处理结果
        combinedFuture.thenAccept(data -> processCombinedData(data));
    }

    private static CompletableFuture<String> fetchFromAPI(String url) {
        // 这里模拟异步网络请求
        return CompletableFuture.supplyAsync(() -> {
            try {
                return new String(URI.create(url).readBytes());
            } catch (Exception e) {
                throw new RuntimeException("Error fetching from API", e);
            }
        });
    }

    private static CompletableFuture<String> fetchFromDatabase(String query) {
        // 这里同样模拟异步数据库查询
        return CompletableFuture.supplyAsync(() -> {
            // 假设数据库操作已封装为返回String的函数
            return DatabaseUtils.query(query);
        });
    }

    private static void processCombinedData(String[] data) {
        // 数据处理逻辑
        System.out.println("Processed data: " + Arrays.toString(data));
    }
}