当前位置：首页 > news >正文

在 Java 中实现异步编程：CompletableFuture 使用指南！

news 来源：原创 2025/5/10 19:41:00

全文目录：

- 开篇语
- 前言
- 1. **什么是 CompletableFuture？**
- 2. **创建 CompletableFuture**
- - 2.1 **使用 runAsync() 创建无返回值的异步任务**
  - 2.2 **使用 supplyAsync() 创建有返回值的异步任务**
- 3. **组合多个异步任务**
- - 3.1 **thenApply() 用于处理异步结果**
  - 3.2 **thenCompose() 用于组合多个依赖任务**
  - 3.3 **thenCombine() 用于组合两个独立的异步任务**
- 4. **异常处理**
- 5. **等待多个异步任务**
- 6. **总结**
- 文末

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

在现代应用中，异步编程越来越成为一个重要的编程模式。它可以有效提高系统的性能和响应性，特别是在处理大量 I/O 操作或耗时任务时。Java 8 引入的 CompletableFuture 类为我们提供了强大的工具来实现异步编程。今天，我们将深入探讨 CompletableFuture 的使用方法以及如何利用它来优化异步任务的执行。

1. 什么是 CompletableFuture？

CompletableFuture 是 Java 8 引入的一个类，它实现了 Future 接口，并增强了其功能。CompletableFuture 允许我们以非阻塞的方式执行异步任务，并且它支持链式调用、组合任务、异常处理等多种功能。

与传统的 Future 类不同，CompletableFuture 可以手动完成（complete），而 Future 只能等待任务完成。CompletableFuture 提供了强大的异步处理能力，让你能够更加方便地管理异步任务。

2. 创建 CompletableFuture

2.1 使用 runAsync() 创建无返回值的异步任务

runAsync() 方法用于创建一个没有返回值的异步任务。在这种情况下，任务执行后不会返回结果，我们只关心任务是否完成。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 使用 runAsync() 创建一个异步任务
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务正在执行...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("异步任务完成");
        });

        // 阻塞等待异步任务完成
        future.join();
        System.out.println("主线程执行完成");
    }
}

2.2 使用 supplyAsync() 创建有返回值的异步任务

runAsync() 适用于没有返回值的任务，而 supplyAsync() 方法用于创建一个有返回值的异步任务。在异步任务执行完成后，可以获取返回值。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        // 使用 supplyAsync() 创建一个有返回值的异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步任务正在执行...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "异步任务完成，返回结果";
        });

        // 获取返回值
        String result = future.join();
        System.out.println("主线程执行完成，异步结果：" + result);
    }
}

3. 组合多个异步任务

CompletableFuture 提供了很多方法来组合多个异步任务，包括 thenApply()、thenCompose()、thenCombine() 等。通过这些方法，我们可以链式地处理多个异步任务。

3.1 thenApply() 用于处理异步结果

thenApply() 方法用于在任务完成后处理结果。它会接收一个函数，对异步任务的返回值进行处理，并返回新的 CompletableFuture。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 10;
        });

        // 使用 thenApply() 处理异步任务的返回结果
        CompletableFuture<Integer> result = future.thenApply(value -> {
            System.out.println("处理异步任务返回值：" + value);
            return value * 2;
        });

        // 获取处理后的结果
        System.out.println("处理后的结果：" + result.join());
    }
}

3.2 thenCompose() 用于组合多个依赖任务

thenCompose() 方法用于将多个异步任务连接成一个串联的任务序列。它适用于需要将一个异步任务的结果作为输入传递给下一个异步任务的情况。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            return 5;
        });

        // 使用 thenCompose() 组合多个异步任务
        CompletableFuture<Integer> result = future.thenCompose(value -> {
            return CompletableFuture.supplyAsync(() -> {
                return value * 2;
            });
        });

        System.out.println("组合后的结果：" + result.join());
    }
}

3.3 thenCombine() 用于组合两个独立的异步任务

thenCombine() 方法用于将两个独立的异步任务的结果进行组合，它会等两个任务都执行完之后，执行合并操作。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
            return 5;
        });

        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            return 10;
        });

        // 使用 thenCombine() 组合两个独立的异步任务
        CompletableFuture<Integer> result = future1.thenCombine(future2, (value1, value2) -> {
            return value1 + value2;
        });

        System.out.println("组合后的结果：" + result.join());
    }
}

4. 异常处理

在异步编程中，异常处理非常重要。CompletableFuture 提供了 exceptionally() 方法来处理异步任务中的异常。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("模拟异常");
        });

        // 使用 exceptionally() 处理异常
        future.exceptionally(ex -> {
            System.out.println("捕获到异常：" + ex.getMessage());
            return -1;
        });

        System.out.println("主线程执行完成");
    }
}

5. 等待多个异步任务

CompletableFuture 还提供了一个非常实用的方法 allOf()，它允许我们等待多个异步任务都执行完毕，然后再继续执行。

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务1正在执行...");
        });

        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            System.out.println("异步任务2正在执行...");
        });

        // 等待所有任务完成
        CompletableFuture.allOf(future1, future2).join();

        System.out.println("所有异步任务执行完毕");
    }
}