Java 8 CompletableFuture：异步编程的强大工具

永夜Evernight

已于 2023-07-14 11:23:13 修改

阅读量291

点赞数

分类专栏： java版本特性解析文章标签： java

于 2023-07-10 16:52:02 首次发布

本文链接：https://blog.youkuaiyun.com/qq_38766930/article/details/131642877

版权

java版本特性解析专栏收录该内容

18 篇文章

订阅专栏

引言

Java 8引入了CompletableFuture类，它是一种强大的工具，用于异步编程和处理异步任务。CompletableFuture提供了一种简洁、灵活的方式来处理异步操作的结果，使得编写并发代码变得更加容易和高效。本教程将介绍CompletableFuture的基本概念、用法以及在实际开发中的应用。

1. 创建和执行异步任务

可以使用CompletableFuture类创建和执行异步任务。它可以用于表示一个异步计算的结果，并提供了一系列方法来处理任务的结果。

下面是一个创建和执行异步任务的示例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // 异步任务的执行逻辑
            return 42;
        });

        int result = future.get(); // 阻塞等待任务的完成并获取结果
        System.out.println("Result: " + result);
    }
}

在上面的代码中，我们使用CompletableFuture.supplyAsync()创建一个异步任务，并在lambda表达式中定义了任务的执行逻辑。然后，使用get()方法阻塞等待任务的完成，并获取任务的结果。

2. 异步任务的串行和并行组合

CompletableFuture提供了一系列方法，可以对异步任务进行串行和并行组合，从而实现更复杂的异步操作。

下面是一个串行和并行组合的示例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 3);

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 * result2);

        int result = combinedFuture.get();
        System.out.println("Result: " + result);
    }
}

在上面的代码中，我们创建了两个异步任务future1和future2，分别返回2和3。然后，使用thenCombine()方法将两个任务的结果进行组合，并定义了组合结果的计算逻辑（这里是相乘）。最后，使用get()方法阻塞等待组合任务的完成，并获取最终结果。

3. 异步任务的异常处理和超时

CompletableFuture提供了异常处理和超时处理的功能，以应对异步任务执行过程中可能出现的异常和超时情况。

下面是一个异常处理和超时处理的示例：

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

public class Main {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Oops!");
        });

        CompletableFuture<Integer> handledFuture = future.exceptionally(throwable -> {
            System.out.println("Exception occurred: " + throwable.getMessage());
            return 0;
        });

        int result = handledFuture.get();
        System.out.println("Result: " + result);

        CompletableFuture<Integer> timeoutFuture = CompletableFuture.supplyAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return 42;
        });

        int timeoutResult = timeoutFuture.orTimeout(2, TimeUnit.SECONDS).get();
        System.out.println("Timeout Result: " + timeoutResult);
    }
}