Java并发编程：CompletableFuture异步技巧详解

还在为Java并发编程中IO密集型任务的性能瓶颈苦恼？本文聚焦`CompletableFuture`在异步文件加载中的应用，深入剖析了传统`ExecutorService.invokeAll()`和循环`CompletableFuture.runAsync().join()`的局限性，揭示了它们无法实现真正并行执行的原因。通过详细的代码示例，我们展示了如何巧妙运用`CompletableFuture.allOf()`，将多个异步任务高效聚合，实现文件加载的并行处理，从而显著提升应用响应速度和吞吐量。此外，文章还提供了实用的错误处理建议和性能考量，助你构建更健壮、更高效的Java并发应用，轻松应对高并发场景下的挑战。掌握`CompletableFuture`异步任务管理技巧，让你的Java程序性能更上一层楼！

本教程探讨了在Java中利用`CompletableFuture`实现异步文件加载并优化性能的方法。针对传统`ExecutorService.invokeAll()`和`CompletableFuture.runAsync().join()`在循环中使用的局限性，文章详细介绍了如何通过`CompletableFuture.allOf()`实现真正的并行任务执行，并提供了详细的代码示例、错误处理建议及性能考量，旨在帮助开发者构建高效、健壮的并发应用。

在Java并发编程中，处理大量IO密集型任务（如文件加载）时，异步执行是提升应用响应速度和吞吐量的关键。ExecutorService和CompletableFuture是Java中实现并发的强大工具。然而，如何正确结合它们以达到最佳性能，特别是当需要等待所有异步任务完成时，是开发者经常面临的挑战。

理解传统并发模式的局限性

在实现异步文件加载时，常见的两种初步尝试可能如下：

1. 使用 ExecutorService.invokeAll() 这种方法通过Callable接口将每个文件处理任务封装起来，然后提交给ExecutorService。invokeAll()方法会阻塞直到所有任务完成，并返回一个Future列表。

   File folderWithJson = new File(pathToFolderWithJson);
   ExecutorService executorService = Executors.newFixedThreadPool(16);
   
   Set<Callable<Boolean>> callables = new HashSet<>();
   for(File file: Objects.requireNonNull(folderWithJson.listFiles())) {
       callables.add(() -> {
           System.out.println(Thread.currentThread().getName());
           return getFineToStat(file); // 假设 getFineToStat(file) 是文件处理逻辑
       });
   }
   executorService.invokeAll(callables); // 阻塞直到所有任务完成
   executorService.shutdown();

   这种方式能够实现并发执行，并等待所有任务完成，但在某些场景下，我们可能希望利用CompletableFuture提供的更灵活的异步编排能力。

2. 循环中不当使用 CompletableFuture.runAsync().join() 为了引入CompletableFuture，有时会尝试在循环中为每个文件创建一个CompletableFuture并立即调用其join()方法。

   File folderWithJson = new File(pathToFolderWithJson);
   ExecutorService executorService = Executors.newFixedThreadPool(16);
   
   for(File file: Objects.requireNonNull(folderWithJson.listFiles())) {
       CompletableFuture.runAsync(() -> {
           try {
               getFineToStat(file); // 假设 getFineToStat(file) 是文件处理逻辑
           } catch (IOException e) {
               throw new RuntimeException(e);
           }
       }, executorService).join(); // 立即阻塞，等待当前任务完成
   }
   executorService.shutdown();

   这种方法的问题在于，CompletableFuture.runAsync(...).join()会立即阻塞当前线程，直到该CompletableFuture完成。这意味着，尽管每个任务都是异步提交的，但由于join()的阻塞特性，实际上文件处理任务是串行执行的，无法实现真正的并行效果，导致性能提升不明显。

利用 CompletableFuture.allOf() 实现高效并行

要实现真正的并行并等待所有CompletableFuture任务完成，正确的做法是先提交所有任务，将它们收集起来，然后使用CompletableFuture.allOf()来等待所有任务的聚合结果。

以下是结合CompletableFuture.allOf()实现异步文件加载的推荐方法：

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Stream;

public class AsyncFileLoader {

    // 假设这是您的文件处理逻辑
    private static Boolean getFineToStat(File file) throws IOException {
        System.out.println("Processing file: " + file.getName() + " by " + Thread.currentThread().getName());
        // 模拟文件处理耗时操作
        try {
            Thread.sleep(100); // 模拟IO或计算密集型操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new IOException("File processing interrupted", e);
        }
        // 实际应用中这里会有文件读取、解析等操作
        return true;
    }

    public static void main(String[] args) {
        // 替换为您的JSON文件目录路径
        String pathToFolderWithJson = "path/to/your/json/folder";
        File folderWithJson = new File(pathToFolderWithJson);

        // 确保目录存在且是目录
        if (!folderWithJson.exists() || !folderWithJson.isDirectory()) {
            System.err.println("Error: Folder does not exist or is not a directory: " + pathToFolderWithJson);
            return;
        }

        // 创建固定大小的线程池
        final ExecutorService executorService = Executors.newFixedThreadPool(16);
        long startTime = System.currentTimeMillis();

        try (Stream<Path> paths = Files.list(folderWithJson.toPath())) {
            // 将每个文件路径映射为一个CompletableFuture任务
            final CompletableFuture<?>[] allFutures = paths
                    .filter(Files::isRegularFile) // 只处理普通文件
                    .map(path -> CompletableFuture.runAsync(() -> {
                        try {
                            getFineToStat(path.toFile());
                        } catch (IOException e) {
                            // 捕获并处理异常，避免中断allOf
                            System.err.println("Error processing file " + path.getFileName() + ": " + e.getMessage());
                            // 可以选择重新抛出 RuntimeException，但会使 allOf 异常完成
                            // throw new RuntimeException(e);
                        }
                    }, executorService)) // 指定在哪个ExecutorService上运行
                    .toArray(CompletableFuture[]::new); // 收集所有CompletableFuture到一个数组

            // 使用 allOf 等待所有CompletableFuture完成
            CompletableFuture.allOf(allFutures).join();

            long endTime = System.currentTimeMillis();
            System.out.println("All files processed in: " + (endTime - startTime) + " ms");

        } catch (IOException e) {
            System.err.println("Error listing files: " + e.getMessage());
        } finally {
            // 关闭线程池
            executorService.shutdown();
            System.out.println("ExecutorService shutdown.");
        }
    }
}

代码解析：

1. ExecutorService 初始化：创建一个固定大小的线程池，用于执行异步任务。线程池的大小应根据CPU核心数和任务类型（IO密集型或CPU密集型）进行调整。
2. Files.list(folderWithJson.toPath())：利用Java NIO.2 的Files.list()方法以流（Stream）的形式获取目录下的所有文件路径。try-with-resources语句确保流在使用完毕后自动关闭，避免资源泄露。
3. .filter(Files::isRegularFile): 过滤掉非普通文件（如子目录）。
4. .map(path -> CompletableFuture.runAsync(...))：这是核心步骤。对于流中的每个文件路径，我们都创建一个CompletableFuture。
   • CompletableFuture.runAsync()接受一个Runnable任务和一个Executor。这里我们将文件处理逻辑getFineToStat(path.toFile())包装在Runnable中，并指定在之前创建的executorService上运行。
   • runAsync()方法会立即将任务提交到executorService，并返回一个CompletableFuture实例，但它不会阻塞当前线程。
5. .toArray(CompletableFuture[]::new)：将所有生成的CompletableFuture实例收集到一个数组中。
6. CompletableFuture.allOf(allFutures).join()：
   • CompletableFuture.allOf(allFutures)接收一个CompletableFuture数组，并返回一个新的CompletableFuture。这个新的CompletableFuture会在数组中的所有原始CompletableFuture都完成时完成。
   • join()方法用于阻塞当前线程，直到allOf返回的CompletableFuture完成。这样就确保了所有文件处理任务都已执行完毕。

错误处理与最佳实践

• 异常处理：CompletableFuture.allOf()的行为是“全有或全无”。如果其中任何一个任务以异常完成，那么allOf返回的CompletableFuture也会以该异常完成。为了避免单个文件处理失败导致整个批次处理中断，建议在每个CompletableFuture.runAsync()内部捕获并处理潜在的IOException，而不是直接向上抛出RuntimeException。这样，即使某个文件处理失败，其他文件也能继续处理。
• 资源管理：使用try-with-resources管理Stream，确保文件流资源得到正确释放。
• 线程池管理：在所有任务完成后，务必调用executorService.shutdown()来优雅地关闭线程池，释放系统资源。
• 性能测量：在实际测试中，为了准确测量不同线程数下的性能差异，需要确保测试环境稳定，并进行多次测量取平均值。同时，文件大小、文件数量、文件IO速度以及getFineToStat方法的实际复杂性都会影响性能表现。

总结

通过CompletableFuture.allOf()结合ExecutorService，我们能够高效地管理和协调多个异步任务，实现真正的并行处理，从而显著提升文件加载等IO密集型任务的性能。这种模式比在循环中调用CompletableFuture.join()更为强大和灵活，是现代Java并发编程中处理复杂异步流程的推荐方法。正确理解其工作原理和异常处理机制，将有助于构建更加健壮和高性能的并发应用。

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《Java并发编程：CompletableFuture异步技巧详解》文章吧，也可关注golang学习网公众号了解相关技术文章。