CompletableFuture探秘：解锁Java并发编程的新境界-阿里云开发者社区

欢迎来到我的博客，代码的世界里，每一行都是一个故事

前言

在Java的世界中，异步编程是应对高并发的利器，而CompletableFuture则是这个工具箱中的瑰宝。就像是一把打开未来之门的钥匙，CompletableFuture为我们提供了更高效、更灵活的并发编程方式。让我们一同踏上这段深入CompletableFuture的实战之旅，发现异步编程的魔力。

第一：CompletableFuture的基础概念

CompletableFuture 是 Java 平台提供的一个强大的异步编程工具，用于处理异步操作和构建非阻塞的异步应用程序。下面是一些基本概念和它与传统 Future 的区别和优势：

CompletableFuture 的基本概念：

异步操作： CompletableFuture 允许你执行异步操作，即在后台线程中执行某些任务，而不阻塞主线程。
组合操作： 你可以将多个 CompletableFuture 实例组合在一起，以便在一个或多个完成时执行进一步的操作。
异常处理： CompletableFuture 提供了更强大的异常处理机制，可以方便地处理异步操作中的异常。
回调函数： 你可以使用回调函数来处理异步操作的结果，而不必等待操作完成。

与传统 Future 的区别和优势：

可编程性： CompletableFuture 提供了更灵活的编程模型，使得异步操作的组合和串联更为容易。
组合操作： 通过方法链（method chaining）的方式，你可以轻松地组合多个异步操作，而不需要复杂的嵌套结构。
异常处理： CompletableFuture 允许你对异常进行更细粒度的控制，可以在异常发生时执行特定的操作。
可观察性： 你可以轻松地监视异步操作的状态，了解它们何时完成，以及它们的结果是成功还是失败。
非阻塞： CompletableFuture 的设计使得异步操作可以在后台线程中执行，不会阻塞主线程的执行。

下面是一个简单的例子，演示了如何使用 CompletableFuture 进行异步操作：

import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
    public static void main(String[] args) {
        // 异步执行任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello, ")
                .thenApplyAsync(result -> result + "world!")
                .thenAcceptAsync(System.out::println);
        // 阻塞主线程，等待异步操作完成
        future.join();
    }
}

在这个例子中，我们首先使用 supplyAsync 方法异步地生成一个字符串，然后使用 thenApplyAsync 进一步处理该字符串，最后使用 thenAcceptAsync 打印结果。这是一个简单的异步操作链。

第二：异步任务的创建与执行

当涉及到创建和执行异步任务时，CompletableFuture 提供了两个主要的静态方法：supplyAsync 和 runAsync。这两个方法都可以用于启动异步任务。下面是一个演示如何使用这些方法的例子：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class AsyncTasksExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 使用 supplyAsync 创建一个异步任务，该任务产生一个字符串结果
        CompletableFuture<String> supplyAsyncFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("Running supplyAsync task on thread: " + Thread.currentThread().getName());
            return "Hello, ";
        });
        // 使用 runAsync 创建一个异步任务，该任务执行一个无返回值的操作
        CompletableFuture<Void> runAsyncFuture = CompletableFuture.runAsync(() -> {
            System.out.println("Running runAsync task on thread: " + Thread.currentThread().getName());
            System.out.println("Doing some asynchronous work.");
        });
        // 等待 supplyAsync 任务完成并获取结果
        String supplyAsyncResult = supplyAsyncFuture.get();
        System.out.println("Result of supplyAsync task: " + supplyAsyncResult);
        // 等待 runAsync 任务完成
        runAsyncFuture.get();
        System.out.println("runAsync task completed.");
        // 注意：在实际应用中，你可能会在异步任务完成时执行更复杂的操作，而不仅仅是调用 get() 方法。
        // 关闭 CompletableFuture 默认使用的 ForkJoinPool，以确保程序正常退出
        CompletableFuture<Void> shutdownFuture = CompletableFuture.runAsync(() -> CompletableFuture.delayedExecutor(1, java.util.concurrent.TimeUnit.SECONDS));
        shutdownFuture.get(); // 阻塞等待关闭完成
    }
}

在这个例子中，我们使用了 supplyAsync 创建了一个返回字符串的异步任务，以及 runAsync 创建了一个没有返回值的异步任务。在实际应用中，异步任务可能会执行一些耗时的操作，例如访问数据库、调用远程服务等。在任务完成后，可以使用 get 方法来获取异步任务的结果，或者执行其他操作。

第三：CompletableFuture的组合与转换

CompletableFuture 提供了丰富的方法，使得你可以轻松地组合和转换异步任务。以下是一些详细的示例，演示了如何使用 thenCombine、thenCompose 等方法进行链式操作：

1. thenCombine 方法

thenCombine 方法允许你在两个 CompletableFuture 完成时执行一个操作，并使用两个任务的结果进行计算。下面是一个例子：

import java.util.concurrent.CompletableFuture;
public class CompletableFutureCombinationExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "world");
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + ", " + result2);
        // 等待组合任务完成并获取结果
        String combinedResult = combinedFuture.join();
        System.out.println(combinedResult);
    }
}

在这个例子中，future1 和 future2 分别产生 “Hello” 和 “world”，然后通过 thenCombine 方法将它们组合在一起，使用lambda表达式将它们连接成一个字符串。

2. thenCompose 方法

thenCompose 方法允许你在一个 CompletableFuture 完成后，将其结果传递给一个函数，并返回一个新的 CompletableFuture。这是一个典型的用法，当你有一个异步任务的结果是另一个异步任务的输入时，可以使用 thenCompose。下面是一个例子：

import java.util.concurrent.CompletableFuture;
public class CompletableFutureCompositionExample {
    public static void main(String[] args) {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
        
        CompletableFuture<String> composedFuture = future1.thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " world"));
        // 等待组合任务完成并获取结果
        String composedResult = composedFuture.join();
        System.out.println(composedResult);
    }
}

在这个例子中，future1 生成 “Hello”，然后通过 thenCompose 方法将其结果传递给一个函数，该函数返回一个新的 CompletableFuture，生成 “Hello world”。

这些方法的灵活性使得你能够以清晰、组织良好的方式组合和转换异步任务的结果。

第四：异常处理与超时控制

CompletableFuture 提供了强大的异常处理机制，同时也支持设置异步任务的超时时间。以下是详细的示例，演示了如何处理异常并设置超时：

1. 异常处理

CompletableFuture 允许你使用 exceptionally 方法来处理异步任务中发生的异常。下面是一个例子：

import java.util.concurrent.CompletableFuture;
public class CompletableFutureExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个可能抛出异常的操作
            if (Math.random() < 0.5) {
                throw new RuntimeException("Oops, something went wrong!");
            }
            return "Hello";
        });
        // 使用 exceptionally 处理异常
        CompletableFuture<String> exceptionHandledFuture = future.exceptionally(ex -> {
            System.err.println("Exception occurred: " + ex.getMessage());
            return "Default Value"; // 提供默认值
        });
        // 等待任务完成并获取结果
        String result = exceptionHandledFuture.join();
        System.out.println("Result: " + result);
    }
}

在这个例子中，supplyAsync 方法模拟了一个可能抛出异常的操作，然后通过 exceptionally 方法处理异常，提供了一个默认值。你可以根据具体需求进行更复杂的异常处理。

2. 超时控制

CompletableFuture 提供了 completeOnTimeout 方法，允许你在指定的超时时间内完成任务，否则使用默认值。下面是一个例子：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
public class CompletableFutureTimeoutExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个长时间运行的操作
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "Hello";
        });
        // 设置超时时间为2秒，并在超时时使用默认值
        CompletableFuture<String> timeoutFuture = future.completeOnTimeout("Default Value", 2, TimeUnit.SECONDS);
        // 等待任务完成并获取结果
        String result = timeoutFuture.join();
        System.out.println("Result: " + result);
    }
}

在这个例子中，supplyAsync 方法模拟了一个长时间运行的操作，然后通过 completeOnTimeout 方法设置了超时时间为2秒，并提供了一个默认值。如果异步任务在超时时间内未完成，将使用默认值。

这些方法为你提供了在异步编程中处理异常和控制超时的灵活性。

第五：CompletableFuture的并发与合并

CompletableFuture 提供了丰富的方法，可以用于执行并发操作并将多个任务的结果进行合并。以下是一些详细的示例，演示如何利用 CompletableFuture 进行并发操作，并使用 allOf、anyOf 等方法进行结果的合并：

1. 并发操作

使用 CompletableFuture.allOf 方法可以并行执行多个任务，等待它们全部完成。下面是一个例子：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class CompletableFutureConcurrentExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result from Task 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result from Task 2");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Result from Task 3");
        // 并行执行多个任务
        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2, future3);
        // 等待所有任务完成
        allOfFuture.get();
        // 获取各个任务的结果
        String result1 = future1.join();
        String result2 = future2.join();
        String result3 = future3.join();
        System.out.println("Result 1: " + result1);
        System.out.println("Result 2: " + result2);
        System.out.println("Result 3: " + result3);
    }
}

在这个例子中，allOf 方法用于并行执行三个任务，并等待它们全部完成。然后，通过 join 方法获取各个任务的结果。

2. 合并结果

CompletableFuture.anyOf 方法用于获取多个任务中任意一个完成的结果。下面是一个例子：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
public class CompletableFutureCombiningExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Result from Task 1");
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "Result from Task 2");
        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "Result from Task 3");
        // 获取任意一个任务完成的结果
        CompletableFuture<Object> anyOfFuture = CompletableFuture.anyOf(future1, future2, future3);
        // 等待任意一个任务完成
        Object result = anyOfFuture.get();
        System.out.println("Result from any task: " + result);
    }
}

在这个例子中，anyOf 方法用于获取三个任务中任意一个任务完成的结果。然后，通过 get 方法获取结果。

这些方法使得你可以方便地执行并发操作，并根据需要合并多个任务的结果。

第六：异步编程的最佳实践

异步编程是一种强大的技术，但也容易引入一些陷阱和错误。以下是一些异步编程的最佳实践以及如何避免常见的问题：

最佳实践：

使用CompletableFuture的工厂方法： CompletableFuture 提供了多个工厂方法，如 supplyAsync 和 runAsync，这些方法可以方便地创建异步任务。
链式操作： 利用 thenApply, thenCompose 和 thenAccept 等方法进行链式操作，以构建清晰的异步任务链。
异常处理： 使用 exceptionally 处理异步任务中的异常，确保你的程序能够优雅地处理错误情况。
超时控制： 使用 completeOnTimeout 或者 orTimeout 方法设置异步任务的超时时间，避免无限期等待任务完成。
并发操作： 使用 allOf 和 anyOf 等方法并行执行多个任务，以提高系统的并发性能。
线程池管理： 在 supplyAsync 和 runAsync 等方法中使用自定义的 Executor 来控制线程池，以防止意外地使用默认的公共线程池。
避免阻塞： 尽量避免在异步任务中使用阻塞操作，因为这会降低异步性能。如果需要阻塞操作，考虑使用异步 API 或者将其委托给另一个线程。

常见陷阱和错误：

忘记等待任务完成： 在异步编程中，确保在需要结果的地方等待任务完成，避免直接调用 join 或 get 方法以外的其他操作。
不正确的异常处理： 异步任务中的异常可能会被吞噬，确保正确使用 exceptionally 处理异常，以及在合适的地方进行日志记录。
忽略线程安全： 如果多个异步任务访问共享状态，确保进行适当的同步，以避免线程安全问题。
过度使用并行操作： 并不是所有的任务都适合并行执行。一些任务可能会受到共享资源的限制，或者因为并行而导致性能下降。
忽略取消和中断： 如果异步任务可以被取消，确保实现了适当的取消机制。此外，考虑线程中断的情况，以便能够响应中断请求。
不适当的线程池使用： 默认情况下，CompletableFuture 使用的是公共的 ForkJoinPool，可能导致线程争用。根据需要，使用自定义的线程池进行任务调度。
不注意资源泄漏： 在使用异步编程时，确保关闭不再需要的资源，防止资源泄漏。

遵循这些最佳实践并注意避免常见的陷阱和错误，可以帮助你更有效地利用异步编程的优势。

第七：CompletableFuture与回调机制

CompletableFuture 通过 thenApply, thenCompose, handle 等方法提供了回调机制，使你能够在异步任务完成时执行特定的操作。以下是一些演示如何使用回调机制的例子：

1. 使用 `thenApply` 处理异步任务的结果

import java.util.concurrent.CompletableFuture;
public class CompletableFutureCallbackExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
        // 使用 thenApply 处理异步任务的结果，并返回一个新的 CompletableFuture
        CompletableFuture<String> callbackFuture = future.thenApply(result -> result + " world");
        // 注册回调函数，在结果准备好时执行
        callbackFuture.thenAccept(finalResult -> System.out.println("Callback Result: " + finalResult));
        // 等待异步任务完成
        future.join();
    }
}

在这个例子中，thenApply 方法用于在异步任务完成时对结果进行处理，并返回一个新的 CompletableFuture。然后，通过 thenAccept 注册回调函数，在结果准备好时执行。

2. 使用 `handle` 处理结果或异常

import java.util.concurrent.CompletableFuture;
public class CompletableFutureHandleExample {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟一个可能抛出异常的操作
            if (Math.random() < 0.5) {
                throw new RuntimeException("Oops, something went wrong!");
            }
            return "Hello";
        });
        // 使用 handle 处理异步任务的结果或异常
        CompletableFuture<String> handleFuture = future.handle((result, exception) -> {
            if (exception != null) {
                System.err.println("Exception occurred: " + exception.getMessage());
                return "Default Value"; // 提供默认值
            } else {
                return result + " world";
            }
        });
        // 注册回调函数，在结果准备好时执行
        handleFuture.thenAccept(finalResult -> System.out.println("Handle Result: " + finalResult));
        // 等待异步任务完成
        future.join();
    }
}

在这个例子中，handle 方法用于处理异步任务的结果或异常。回调函数接收两个参数：任务的结果和可能的异常。通过检查异常，你可以决定如何处理结果或提供默认值。

通过这些方法，你可以灵活地处理异步任务的结果和异常，从而实现回调机制。

第八：性能优化与调优

性能优化和调优在异步编程中至关重要，尤其是在高负载环境中。以下是一些建议和技巧，帮助你优化 CompletableFuture 的性能：

1. 合理使用线程池

指定自定义线程池： 默认情况下，CompletableFuture 使用公共的 ForkJoinPool。在高负载环境中，考虑创建自定义的线程池，并在异步任务中指定该线程池，以防止与其他任务争用线程资源。

Executor customExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello", customExecutor);

合理调整线程池大小： 根据应用的负载和硬件配置，调整线程池的大小以达到最佳性能。使用过大的线程池可能会导致资源浪费，而使用过小的线程池可能导致性能下降。

2. 避免阻塞操作

使用异步 API： 尽量避免在异步任务中使用同步的、阻塞的 API。如果必须使用阻塞操作，考虑将其委托给另一个线程，以防止阻塞主线程。

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
 // 避免在此处使用阻塞操作
 doSomeNonBlockingWork();
});

3. 批处理和并发操作

批处理： 将相关的任务分组并批量处理，以减少线程切换的开销。

List<CompletableFuture<String>> futures = new ArrayList<>();
for (int i = 0; i < 10; i++) {
 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Task " + i);
 futures.add(future);
}
CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));

并发操作： 使用 allOf 和 anyOf 等方法，以提高系统的并发性能。

4. 调整超时时间

设置合理的超时时间： 使用 completeOnTimeout 或者 orTimeout 方法设置异步任务的超时时间，以避免任务过长的等待时间。

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 // 长时间运行的操作
 return "Result";
});
CompletableFuture<String> timeoutFuture = future.completeOnTimeout("Default Result", 5, TimeUnit.SECONDS);

5. 内存管理

避免内存泄漏： 在异步编程中，确保及时关闭不再需要的资源，以避免内存泄漏。

6. 监控和调试

使用监控工具： 利用性能监控工具（例如 VisualVM、JProfiler 等）来分析应用程序的异步任务执行情况，并找出性能瓶颈。
日志记录： 在异步任务中适当记录日志，以便跟踪任务的执行流程和性能信息。

这些技巧可以帮助你优化 CompletableFuture 的性能，并在高负载环境中获得更好的性能表现。根据具体情况，可能需要进行更深入的性能分析和调优。

第九：Java中的其他并发工具与CompletableFuture的比较

在 Java 中，有许多并发工具可用，包括 Executor 框架、ForkJoin 框架等。以下是 CompletableFuture 与其他并发工具的比较，以及在何种情况下选择使用 CompletableFuture 的一些建议：

1. Executor 框

CompletableFuture 优势：

CompletableFuture 是基于 Executor 的，但它提供了更高级别的抽象，允许你更方便地进行异步编程。
CompletableFuture 允许你通过方法链（method chaining）的方式组合多个异步任务，更容易构建异步任务链。

选择情景：

如果只需要简单的异步执行，且不需要多个异步任务之间的复杂关系，使用 Executor 可能更为直观和轻量。

2. ForkJoin 框

CompletableFuture 优势：

CompletableFuture 可以与 ForkJoinPool 集成，允许你更灵活地进行并行操作。
通过 allOf 和 anyOf 方法，CompletableFuture 提供了更方便的并发操作方法。

选择情景：

如果问题可以通过任务分割和递归的方式解决，并且你需要更细粒度的并行操作，那么 ForkJoin 框架可能更适合。
如果你更关心异步任务的组合和链式操作，或者需要更高级别的异常处理和超时控制，那么选择 CompletableFuture 更为合适。

3. 选择 `CompletableFuture` 的情景

组合和链式操作： 当你需要执行复杂的异步操作链时，CompletableFuture 提供了更灵活的方法，能够方便地组合和链式调用异步任务。
异常处理和超时控制： CompletableFuture 提供了更丰富的异常处理机制和超时控制，使得你能够更好地处理异步任务中可能出现的问题。
更高级别的抽象： 如果你希望在异步任务中使用更高级别的抽象，例如回调函数、条件判断等，CompletableFuture 提供了更多的便利。
并发和并行操作： 对于需要并发执行多个任务或并行操作的场景，CompletableFuture 提供了 allOf 和 anyOf 等方法，使得并发操作更为容易。

总体而言，CompletableFuture 在处理异步编程时提供了更高级别、更灵活的抽象，适用于复杂的异步场景。选择 CompletableFuture 的主要考虑因素包括异步任务的组合性质、对异常的处理需求、以及是否需要更高级别的并发控制。

结语

深深感谢你阅读完整篇文章，希望你从中获得了些许收获。如果觉得有价值，欢迎点赞、收藏，并关注我的更新，期待与你共同分享更多技术与思考。

CompletableFuture探秘：解锁Java并发编程的新境界

前言

第一：CompletableFuture的基础概念

第二：异步任务的创建与执行

第三：CompletableFuture的组合与转换

1. thenCombine 方法

2. thenCompose 方法

第四：异常处理与超时控制

1. 异常处理

2. 超时控制

第五：CompletableFuture的并发与合并

1. 并发操作

2. 合并结果

第六：异步编程的最佳实践

最佳实践：

常见陷阱和错误：

第七：CompletableFuture与回调机制

1. 使用 `thenApply` 处理异步任务的结果

2. 使用 `handle` 处理结果或异常

第八：性能优化与调优

1. 合理使用线程池

2. 避免阻塞操作

3. 批处理和并发操作

4. 调整超时时间

5. 内存管理

6. 监控和调试

第九：Java中的其他并发工具与CompletableFuture的比较

1. Executor 框

2. ForkJoin 框

3. 选择 `CompletableFuture` 的情景

结语

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

CompletableFuture探秘：解锁Java并发编程的新境界

前言

第一：CompletableFuture的基础概念

第二：异步任务的创建与执行

第三：CompletableFuture的组合与转换

1. thenCombine 方法

2. thenCompose 方法

第四：异常处理与超时控制

1. 异常处理

2. 超时控制

第五：CompletableFuture的并发与合并

1. 并发操作

2. 合并结果

第六：异步编程的最佳实践

最佳实践：

常见陷阱和错误：

第七：CompletableFuture与回调机制

1. 使用 thenApply 处理异步任务的结果

2. 使用 handle 处理结果或异常

第八：性能优化与调优

1. 合理使用线程池

2. 避免阻塞操作

3. 批处理和并发操作

4. 调整超时时间

5. 内存管理

6. 监控和调试

第九：Java中的其他并发工具与CompletableFuture的比较

1. Executor 框

2. ForkJoin 框

3. 选择 CompletableFuture 的情景

结语

热门文章

最新文章

相关课程

相关电子书

相关实验场景

1. 使用 `thenApply` 处理异步任务的结果

2. 使用 `handle` 处理结果或异常

3. 选择 `CompletableFuture` 的情景