CompletableFuture 异步-前言

在现代Java开发中，处理并发任务和异步编程已成为关键需求。Java 8引入的 CompletableFuture 提供了一种强大的方式来简化异步编程，使其更加直观和易于维护。与传统的线程或 Future 方法相比，CompletableFuture 提供了更高层次的抽象，允许开发者以声明式的方式编写异步代码。这篇文章将探讨 CompletableFuture 的基本概念和用法，帮助你掌握这一强大的工具，提升Java应用程序的性能和响应性。本文章提供CompletableFuture的基础用法和最佳实践。

背景

在早期的Java版本中，处理并发任务主要依赖于 Thread 类和 Executor 框架。这些方法虽然强大，但在处理复杂的异步流程时显得笨重和难以管理。Future 接口引入后，提供了一个表示异步计算结果的方式，但它的局限性在于获取结果时必须调用阻塞方法 get()，无法方便地进行非阻塞操作和链式调用。

为了解决这些问题，Java 8引入了 CompletableFuture，它不仅实现了 Future 接口，还提供了丰富的API，用于创建、组合和处理异步任务。通过使用 CompletableFuture，开发者可以编写更清晰、简洁的异步代码，避免复杂的回调地狱问题。

主要特性

CompletableFuture 的主要特性包括：

1. 异步任务执行：可以轻松地在后台线程中执行任务，而不阻塞主线程。
2. 任务组合：支持多种方式将多个异步任务组合在一起，如 thenCompose 和 thenCombine。
3. 异常处理：提供了处理异步任务中异常的便捷方法，如 handle 和 exceptionally。
4. 回调机制：允许在任务完成时自动执行回调函数，而不需要显式地阻塞等待结果。
   

1. 异步任务执行

CompletableFuture 可以轻松地在后台线程中执行任务，而不阻塞主线程。例如：

   @Test
    public void testAsyncTaskExecution() throws ExecutionException, InterruptedException, TimeoutException {
        System.out.println("启动异步线程执行任务");
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("正在执行异步线程任务");
            // 模拟异步任务
            return "Hello, Async!";
        });
        System.out.println("执行主线程任务");
        // 验证结果
        System.out.println("等待异步线程执行完成");
        String result = future.get(1, TimeUnit.SECONDS);
        System.out.println("异步线程执行完毕，打印结果");
        System.out.println(result);
    }

测试结果如下：

启动异步线程执行任务
执行主线程任务
等待异步线程执行完成
正在执行异步线程任务
异步线程执行完毕，打印结果
Hello, Async!

2. 任务组合

用于将一个异步任务的结果作为下一个异步任务的输入。

    @Test
    public void testTaskComposition() throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "任务1执行结果")
                .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " 任务2执行结果"));

        // 验证结果
        String result = future.get(1, TimeUnit.SECONDS);
        System.out.println(result);
    }

结果如下：

任务1执行结果 任务2执行结果

3. 异常处理

CompletableFuture 提供了处理异步任务中异常的便捷方法：

    @Test
    public void testExceptionHandling() throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            if (true) {
                throw new RuntimeException("任务执行过程中出现异常。");
            }
            return "任务执行成功";
        }).exceptionally(ex -> "任务执行出现异常，返回一个默认值");

        // 验证结果
        String result = future.get(1, TimeUnit.SECONDS);
        System.out.println(result);
    }

任务执行出现异常，返回一个默认值

4. 回调机制

CompletableFuture 允许在任务完成时自动执行回调函数，而不需要显式地阻塞等待结果：

    @Test
    public void testCallbackMechanism() throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "任务执行成功。")
                .thenApply(result -> result + "回调方法执行成功。");

        // 验证结果
        String result = future.get(1, TimeUnit.SECONDS);
        System.out.println(result);
    }

任务执行成功。回调方法执行成功。

最佳实践

处理多个数据统计接口是一项常见的需求，尤其是在微服务架构或分布式系统中。CompletableFuture 提供了强大的工具来并行调用这些接口，汇总结果，并提高整体性能。以下是一些最佳实践，帮助你高效地处理多个数据统计接口。

并行调用多个接口

使用 CompletableFuture 的异步特性，可以并行调用多个接口，避免顺序调用带来的性能瓶颈。

示例如下：

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

public class StatisticsService {

    public CompletableFuture<Integer> fetchStatisticA() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟调用接口 A
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        });
    }

    public CompletableFuture<Integer> fetchStatisticB() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟调用接口 B
            try {
                TimeUnit.SECONDS.sleep(2); // 模拟延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 200;
        });
    }

    public CompletableFuture<Integer> fetchStatisticC() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟调用接口 C
            try {
                TimeUnit.SECONDS.sleep(3); // 模拟延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 300;
        });
    }

    public int aggregateStatistics() throws ExecutionException, InterruptedException, TimeoutException {
        CompletableFuture<Integer> futureA = fetchStatisticA();
        CompletableFuture<Integer> futureB = fetchStatisticB();
        CompletableFuture<Integer> futureC = fetchStatisticC();

        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureA, futureB, futureC);

        // 等待所有任务完成
        allOf.get(5, TimeUnit.SECONDS);

        // 聚合结果
        int resultA = futureA.get();
        int resultB = futureB.get();
        int resultC = futureC.get();

        return resultA + resultB + resultC;
    }

    public static void main(String[] args) {
        StatisticsService service = new StatisticsService();
        try {
            int total = service.aggregateStatistics();
            System.out.println("Total Statistics: " + total);
        } catch (ExecutionException | InterruptedException | TimeoutException e) {
            e.printStackTrace();
        }
    }
}

解释

• 异步任务：fetchStatisticA、fetchStatisticB 和 fetchStatisticC 分别异步调用三个不同的数据统计接口。
• 并行执行：使用 CompletableFuture.supplyAsync 方法并行调用这些接口。
• 聚合结果：使用 CompletableFuture.allOf 等待所有异步任务完成后，再聚合结果。

测试结果如下：

Total Statistics: 600

处理异常

在调用多个接口时，某些接口可能会失败。使用 CompletableFuture 提供的异常处理方法，可以优雅地处理这些情况。
示例如下：

public int aggregateStatisticsWithExceptionHandling() {
    CompletableFuture<Integer> futureA = fetchStatisticA()
        .exceptionally(ex -> {
            System.err.println("Failed to fetch statistic A: " + ex.getMessage());
            return 0;
        });

    CompletableFuture<Integer> futureB = fetchStatisticB()
        .exceptionally(ex -> {
            System.err.println("Failed to fetch statistic B: " + ex.getMessage());
            return 0;
        });

    CompletableFuture<Integer> futureC = fetchStatisticC()
        .exceptionally(ex -> {
            System.err.println("Failed to fetch statistic C: " + ex.getMessage());
            return 0;
        });

    CompletableFuture<Void> allOf = CompletableFuture.allOf(futureA, futureB, futureC);

    try {
        // 等待所有任务完成
        allOf.get(5, TimeUnit.SECONDS);

        // 聚合结果
        int resultA = futureA.get();
        int resultB = futureB.get();
        int resultC = futureC.get();

        return resultA + resultB + resultC;
    } catch (ExecutionException | InterruptedException | TimeoutException e) {
        e.printStackTrace();
        return 0;
    }
}

解释：

• 异常处理：使用 exceptionally 方法为每个异步任务添加异常处理逻辑。当任务失败时，提供默认值（如0）。
• 聚合结果：同样地，在所有任务完成后，聚合结果，并返回总统计值。

超时设置

为了防止单个接口调用过慢导致整体延迟，可以为每个异步任务设置超时时间。

public CompletableFuture<Integer> fetchStatisticAWithTimeout() {
    return CompletableFuture.supplyAsync(() -> {
        // 模拟调用接口 A
        try {
            TimeUnit.SECONDS.sleep(1); // 模拟延迟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return 100;
    }).completeOnTimeout(0, 2, TimeUnit.SECONDS); // 超时设置
}

解释

• 超时设置：使用 completeOnTimeout 方法为异步任务设置超时，当超时时返回默认值（如0）。

使用 Executor 自定义线程池

默认情况下，CompletableFuture 使用 ForkJoinPool.commonPool() 作为线程池。可以通过自定义线程池来控制异步任务的执行资源。

import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class StatisticsService {

    private final ExecutorService executor = Executors.newFixedThreadPool(10);

    public CompletableFuture<Integer> fetchStatisticA() {
        return CompletableFuture.supplyAsync(() -> {
            // 模拟调用接口 A
            try {
                TimeUnit.SECONDS.sleep(1); // 模拟延迟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 100;
        }, executor);
    }

    // 同样地，fetchStatisticB 和 fetchStatisticC 方法也可以使用 executor 进行调用

    public void shutdown() {
        executor.shutdown();
    }
}

解释:

• 自定义线程池：使用 Executors.newFixedThreadPool 创建一个固定大小的线程池，传递给 supplyAsync
  方法以控制异步任务的执行。

总结

通过 CompletableFuture，你可以高效地并行调用多个数据统计接口，并在这些任务完成后聚合结果。上述最佳实践包括并行调用、异常处理、超时设置以及自定义线程池，帮助你编写更健壮和高效的异步代码。通过这些实践，你可以提升应用程序的性能和用户体验。

总结

CompletableFuture 是 Java 异步编程的利器，通过它可以简化异步任务的创建、组合和处理。掌握 CompletableFuture 可以帮助你编写更高效、更易维护的异步代码，提升应用程序的性能和用户体验。