本教程探讨了在Java中利用`CompletableFuture`实现异步文件加载并优化性能的方法。针对传统`ExecutorService.invokeAll()`和`CompletableFuture.runAsync().join()`在循环中使用的局限性，文章详细介绍了如何通过`CompletableFuture.allOf()`实现真正的并行任务执行，并提供了详细的代码示例、错误处理建议及性能考量，旨在帮助开发者构建高效、健壮的并发应用。
在Java并发编程中，处理大量IO密集型任务（如文件加载）时，异步执行是提升应用响应速度和吞吐量的关键。ExecutorService和CompletableFuture是Java中实现并发的强大工具。然而，如何正确结合它们以达到最佳性能，特别是当需要等待所有异步任务完成时，是开发者经常面临的挑战。
理解传统并发模式的局限性
在实现异步文件加载时，常见的两种初步尝试可能如下：
-
使用 ExecutorService.invokeAll() 这种方法通过Callable接口将每个文件处理任务封装起来，然后提交给ExecutorService。invokeAll()方法会阻塞直到所有任务完成，并返回一个Future列表。
File folderWithJson = new File(pathToFolderWithJson); ExecutorService executorService = Executors.newFixedThreadPool(16); Set
这种方式能够实现并发执行，并等待所有任务完成，但在某些场景下，我们可能希望利用CompletableFuture提供的更灵活的异步编排能力。
立即学习“Java免费学习笔记（深入）”；
-
循环中不当使用 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 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.");
}
}
} 代码解析：
- ExecutorService 初始化：创建一个固定大小的线程池，用于执行异步任务。线程池的大小应根据CPU核心数和任务类型（IO密集型或CPU密集型）进行调整。
-
Files.list(folderWithJson.toPath())：利用Java NIO.2 的Files.list()方法以流（Stream
）的形式获取目录下的所有文件路径。try-with-resources语句确保流在使用完毕后自动关闭，避免资源泄露。 - .filter(Files::isRegularFile): 过滤掉非普通文件（如子目录）。
-
.map(path -> CompletableFuture.runAsync(...))：这是核心步骤。对于流中的每个文件路径，我们都创建一个CompletableFuture。
- CompletableFuture.runAsync()接受一个Runnable任务和一个Executor。这里我们将文件处理逻辑getFineToStat(path.toFile())包装在Runnable中，并指定在之前创建的executorService上运行。
- runAsync()方法会立即将任务提交到executorService，并返回一个CompletableFuture
实例，但它不会阻塞当前线程。
- .toArray(CompletableFuture[]::new)：将所有生成的CompletableFuture实例收集到一个数组中。
-
CompletableFuture.allOf(allFutures).join()：
- CompletableFuture.allOf(allFutures)接收一个CompletableFuture数组，并返回一个新的CompletableFuture
。这个新的CompletableFuture会在数组中的所有原始CompletableFuture都完成时完成。 - join()方法用于阻塞当前线程，直到allOf返回的CompletableFuture完成。这样就确保了所有文件处理任务都已执行完毕。
- CompletableFuture.allOf(allFutures)接收一个CompletableFuture数组，并返回一个新的CompletableFuture
错误处理与最佳实践
- 异常处理：CompletableFuture.allOf()的行为是“全有或全无”。如果其中任何一个任务以异常完成，那么allOf返回的CompletableFuture也会以该异常完成。为了避免单个文件处理失败导致整个批次处理中断，建议在每个CompletableFuture.runAsync()内部捕获并处理潜在的IOException，而不是直接向上抛出RuntimeException。这样，即使某个文件处理失败，其他文件也能继续处理。
-
资源管理：使用try-with-resources管理Stream
，确保文件流资源得到正确释放。 - 线程池管理：在所有任务完成后，务必调用executorService.shutdown()来优雅地关闭线程池，释放系统资源。
- 性能测量：在实际测试中，为了准确测量不同线程数下的性能差异，需要确保测试环境稳定，并进行多次测量取平均值。同时，文件大小、文件数量、文件IO速度以及getFineToStat方法的实际复杂性都会影响性能表现。
总结
通过CompletableFuture.allOf()结合ExecutorService，我们能够高效地管理和协调多个异步任务，实现真正的并行处理，从而显著提升文件加载等IO密集型任务的性能。这种模式比在循环中调用CompletableFuture.join()更为强大和灵活，是现代Java并发编程中处理复杂异步流程的推荐方法。正确理解其工作原理和异常处理机制，将有助于构建更加健壮和高性能的并发应用。
