如何利用Java 8特性并行执行多个SQL查询方法？

嗨，我来帮你搞定Java 8并行执行这三个SQL查询方法的问题！

其实Java 8里有两种常用的方式可以实现，我给你详细拆解下，顺便帮你排查下之前可能踩的坑：

方案一：用CompletableFuture（推荐，更灵活） #

CompletableFuture是Java 8引入的异步编程工具，非常适合这种需要并行执行多个任务并收集结果的场景，而且能很好地处理异常和自定义线程池。

步骤1：把每个查询方法包装成异步任务 #

假设你的三个方法签名是这样的（根据实际情况调整类型）：

List<User> fetchUsers();
List<Order> fetchOrders();
List<Product> fetchProducts();

我们用supplyAsync把每个方法包装成异步任务，它们会立刻并行执行，不用等前一个完成：

// 每个任务会被提交到默认的ForkJoinPool线程池，并行执行
CompletableFuture<List<User>> userFuture = CompletableFuture.supplyAsync(this::fetchUsers);
CompletableFuture<List<Order>> orderFuture = CompletableFuture.supplyAsync(this::fetchOrders);
CompletableFuture<List<Product>> productFuture = CompletableFuture.supplyAsync(this::fetchProducts);

步骤2：等待所有任务完成并获取结果 #

用allOf()来等待所有异步任务结束，然后逐个取出结果：

try {
    // 阻塞等待所有任务完成
    CompletableFuture.allOf(userFuture, orderFuture, productFuture).get();
    
    // 安全获取每个任务的结果
    List<User> users = userFuture.get();
    List<Order> orders = orderFuture.get();
    List<Product> products = productFuture.get();
    
    // 在这里处理三个结果列表就好啦
} catch (InterruptedException e) {
    // 处理线程中断异常
    Thread.currentThread().interrupt();
} catch (ExecutionException e) {
    // 处理任务执行时的异常（比如SQL查询出错）
    Throwable actualException = e.getCause();
    actualException.printStackTrace();
}

进阶：自定义线程池（适合IO密集型任务） #

因为SQL查询是IO密集型操作，默认的ForkJoinPool线程数是CPU核心数，可能不够用。你可以自定义线程池来优化：

// 创建一个固定大小的线程池，比如3个线程对应三个任务
ExecutorService customExecutor = Executors.newFixedThreadPool(3);

// 把自定义线程池传给supplyAsync
CompletableFuture<List<User>> userFuture = CompletableFuture.supplyAsync(this::fetchUsers, customExecutor);
CompletableFuture<List<Order>> orderFuture = CompletableFuture.supplyAsync(this::fetchOrders, customExecutor);
CompletableFuture<List<Product>> productFuture = CompletableFuture.supplyAsync(this::fetchProducts, customExecutor);

try {
    CompletableFuture.allOf(userFuture, orderFuture, productFuture).get();
    // 获取结果...
} catch (Exception e) {
    e.printStackTrace();
} finally {
    // 记得关闭线程池，避免资源泄漏
    customExecutor.shutdown();
}

方案二：用并行流（注意避坑） #

如果你想用并行流实现，一定要注意不要提前执行方法！很多人踩坑是因为直接把方法调用的结果放进流里，导致顺序执行。正确的写法是把方法包装成Supplier，让并行流去触发执行：

// 把方法引用包装成Supplier，并行流会触发每个Supplier的get()方法并行执行
List<List<?>> allResults = Stream.<Supplier<List<?>>>of(
    this::fetchUsers,
    this::fetchOrders,
    this::fetchProducts
)
.parallel()
.map(Supplier::get)
.collect(Collectors.toList());

// 之后可以从allResults里取出三个列表，比如：
List<User> users = (List<User>) allResults.get(0);
List<Order> orders = (List<Order>) allResults.get(1);
List<Product> products = (List<Product>) allResults.get(2);

如果之前你写的是Stream.of(fetchUsers(), fetchOrders(), fetchProducts()).parallel()，那肯定是顺序执行的——因为fetchUsers()这些方法在创建Stream之前就已经同步执行完了，并行流根本没起到作用！

为什么推荐CompletableFuture？ #

相比并行流，它的优势在于：

• 能单独处理每个任务的异常，不会因为一个任务失败导致整个流终止
• 可以自定义线程池，更适合IO密集型的SQL查询
• 支持更复杂的异步流程（比如某个任务依赖另一个任务的结果，不过你这里不需要）

内容的提问来源于stack exchange，提问作者sunil