代码收藏家技术教程 2025-01-20

Java异步编程利器：CompletableFuture实战

1. 引言

2. 基础概念

2.1 为什么需要CompletableFuture？

3. 核心应用场景

3.1 异步执行任务

3.2 任务编排和组合

3.3 异常处理

3.4 超时控制

3.5 并行任务处理

4. 最佳实践

4.1 线程池管理

4.2 性能优化建议

5. 实际应用场景

5.1 微服务调用

5.2 异步API设计

6. 总结

参考资料

1. 引言

在现代 Java 应用程序开发中，异步编程已经成为提升系统性能和用户体验的重要手段。CompletableFuture 作为 Java 8 引入的异步编程工具，不仅提供了 Future 接口的增强版本，还支持函数式编程，使得异步任务的编排和组合变得更加灵活和直观。本文将深入探讨 CompletableFuture 的各种应用场景，帮助你更好地掌握这个强大的工具。

2. 基础概念

2.1 为什么需要CompletableFuture？

传统的Future接口存在以下局限性：

无法手动完成计算

不支持异步任务的编排和组合

无法处理计算过程中的异常

无法设置回调函数

CompletableFuture 通过提供丰富的 API 解决了这些问题，成为了异步编程的首选工具。

3. 核心应用场景

3.1 异步执行任务

最基本的场景是异步执行一个任务：

public class AsyncExecution {
    public String asyncOperation() {
        CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "操作完成";
        });

        return "无需等待";
    }
}

3.2 任务编排和组合

CompletableFuture 提供了多种方法来组合异步任务：

    @SneakyThrows
    public void combineTasks() {
        // 创建两个异步任务 future1 和 future2，分别返回字符串 "Hello" 和 "World"
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

        // 使用 thenCombine 方法将两个异步任务的结果合并为一个字符串 "Hello World"
        CompletableFuture<String> combined = future1
                .thenCombine(future2, (result1, result2) -> result1 + " " + result2);

        // 使用 get() 方法等待并获取合并后的结果，并打印出来。
        combined.thenAccept(System.out::println);
    }

    public void chainTasks() {
        // 使用CompletableFuture的supplyAsync方法异步执行第一个任务，任务结果为"步骤1"
        CompletableFuture.supplyAsync(() -> "步骤1")
                // 使用thenApply方法将前一个任务的结果与" -> 步骤2"拼接，表示第二个任务
                .thenApply(result -> result + " -> 步骤2")
                .thenApply(result -> result + " -> 步骤3")
                // 使用thenAccept方法消费最终结果，这里只是简单地打印出来
                .thenAccept(System.out::println);
    }

3.3 异常处理

优雅的异常处理是CompletableFuture的一大特色：

    public void handleErrors() {
        // 创建一个CompletableFuture，用于执行异步操作
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个可能失败的操作
            if (Math.random() < 0.5) {
                // 如果操作失败，抛出运行时异常
                throw new RuntimeException("操作失败");
            }
            // 如果操作成功，返回成功信息
            return "操作成功";
        }).exceptionally(throwable -> {
            // 处理由前一个阶段（如 supplyAsync、thenApply 等）抛出的异常。
            return "发生错误：" + throwable.getMessage();
        }).handle((result, throwable) -> {
            // 处理所有异常，包括前一个阶段抛出的异常以及后续链式调用中抛出的异常
            if (throwable != null) {
                // 如果有异常，处理异常并返回处理信息
                return "处理异常：" + throwable.getMessage();
            }
            // 如果没有异常，直接返回结果
            return result;
        });

        // 当future完成时，接受其结果并进行处理
        future.thenAccept(System.out::println);
    }

3.4 超时控制

在实际应用中，超时控制非常重要，orTimeout() 需要 Java 9+支持：

    @SneakyThrows
    public void getWithTimeout() {
        CompletableFuture.supplyAsync(() -> {
                    // 模拟耗时操作
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "操作结果";
                })
                // 设置超时时间为1秒，如果超过1秒未完成任务，则抛出CompletionException异常
                .orTimeout(1, TimeUnit.SECONDS)
                // 获取异步操作结果，可能抛出InterruptedException或ExecutionException异常，故使用@SneakyThrows注解理这些异常
                .get();
    }

3.5 并行任务处理

当需要并行执行多个任务时：

    public void executeParallel() {
        // 创建并初始化一个包含三个异步任务的列表
        List<CompletableFuture<String>> futures = Arrays.asList(
                CompletableFuture.supplyAsync(() -> "任务1"),
                CompletableFuture.supplyAsync(() -> "任务2"),
                CompletableFuture.supplyAsync(() -> "任务3")
        );

        // 使用allOf方法等待所有任务完成，并在所有任务完成后执行特定操作
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .thenRun(() -> System.out.println("所有任务完成"));
    }

4. 最佳实践

4.1 线程池管理

推荐使用自定义线程池而不是默认的 ForkJoinPool：

public class ThreadPoolManagement {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
  
    public CompletableFuture<String> executeWithCustomPool() {
        return CompletableFuture.supplyAsync(() -> {
            // 执行任务
            return "使用自定义线程池";
        }, executor);
    }
}

4.2 性能优化建议

合理设置线程池大小
避免不必要的任务等待
使用合适的组合操作符
注意异常处理的性能开销

5. 实际应用场景

5.1 微服务调用

public class MicroserviceExample {
    public CompletableFuture<OrderDTO> processOrder(Long orderId) {
        // 并行启动三个异步任务，分别获取订单信息、用户信息和支付信息
        CompletableFuture<OrderInfo> orderFuture = getOrderInfo(orderId);
        CompletableFuture<UserInfo> userFuture = getUserInfo(orderId);
        CompletableFuture<PaymentInfo> paymentFuture = getPaymentInfo(orderId);
  
        // 等待所有异步任务完成，并将结果封装到OrderDTO对象中
        return CompletableFuture.allOf(orderFuture, userFuture, paymentFuture)
            .thenApply(v -> {
                OrderDTO dto = new OrderDTO();
                dto.setOrderInfo(orderFuture.join());
                dto.setUserInfo(userFuture.join());
                dto.setPaymentInfo(paymentFuture.join());
                return dto;
            });
    }
}

在微服务架构中，经常需要调用多个服务并组合结果：

5.2 异步API设计

设计异步 API 时的最佳实践：

public interface AsyncService {
    CompletableFuture<Result> asyncOperation();
  
    default Result syncOperation() {
        try {
            return asyncOperation().get(5, TimeUnit.SECONDS);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}