CompletableFuture未等待子线程完成，恳请帮忙排查问题

你尝试等待带有@Async注解、返回值为void的processor.processFiles()方法执行完成，但自定义的忙等待逻辑无法生效，核心问题出在对@Async机制的误用以及低效的等待方式上，先看你的原始代码：

try{
    filesList.forEach(files -> {
        List<CompletableFuture<Void>> completableFutures  = new ArrayList<>();

        files.forEach(file-> {
            CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> 
                processor.processFiles());
            completableFutures.add(completableFuture);
        });
        while(true) {
            Thread.sleep(5000);
            boolean isComplete = completableFutures.stream().allMatch(result -> result.isDone() == true);
            if(isComplete){
                break;
            }
            LOGGER.info("processing the file...");
        }
    });
} 
catch(Exception e){
}
finally{
    closeConnections();
}

你忽略的关键问题 #

1. @Async void方法的执行特性被误解 #

被@Async标记的void方法，Spring会将其业务逻辑提交到异步线程池执行，方法本身会立即返回。你用CompletableFuture.runAsync包装这个方法时，CompletableFuture只会等待到processor.processFiles()的调用结束（也就是方法立即返回的那一刻），而非真正的异步业务逻辑执行完毕。这就导致你的completableFutures会很快全部变成done状态，但实际文件处理任务还在后台运行。

2. 重复创建局部Future列表 #

在filesList.forEach的每次循环中，你都新建了completableFutures局部列表，这会导致每次循环的任务状态无法被正确跟踪（不过这不是核心问题，但属于代码冗余）。

3. 自定义忙等待的低效与不可靠 #

用while(true)加Thread.sleep()的循环等待，不仅浪费CPU资源，还可能因为线程调度延迟导致判断不准确，CompletableFuture本身提供了更优雅的批量等待方法。

正确的解决方案 #

方案一：修改@Async方法的返回值（推荐） #

将processor.processFiles()的返回值从void改为CompletableFuture<Void>，这样Spring会返回异步任务的Future实例，直接跟踪任务真实状态：

// 修改processor的方法定义
@Async
public CompletableFuture<Void> processFiles() {
    // 原文件处理业务逻辑
    return CompletableFuture.completedFuture(null);
}

// 调用方代码修改
try {
    filesList.forEach(files -> {
        List<CompletableFuture<Void>> completableFutures = new ArrayList<>();

        files.forEach(file -> {
            // 直接收集@Async方法返回的Future
            CompletableFuture<Void> future = processor.processFiles();
            completableFutures.add(future);
        });

        // 用CompletableFuture内置方法等待所有任务完成
        CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0])).join();
        LOGGER.info("当前批次文件处理完成");
    });
} catch (Exception e) {
    LOGGER.error("文件处理出错", e);
} finally {
    closeConnections();
}

方案二：用CountDownLatch跟踪任务（无法修改方法返回值时） #

如果不能修改processor.processFiles()的返回值，可以通过CountDownLatch来统计任务完成数：

try {
    filesList.forEach(files -> {
        CountDownLatch latch = new CountDownLatch(files.size());

        files.forEach(file -> {
            // 传入latch到异步方法
            processor.processFiles(latch);
        });

        // 等待所有任务完成
        latch.await();
        LOGGER.info("当前批次文件处理完成");
    });
} catch (Exception e) {
    LOGGER.error("文件处理出错", e);
} finally {
    closeConnections();
}

// 修改processor的方法：
@Async
public void processFiles(CountDownLatch latch) {
    try {
        // 原文件处理业务逻辑
    } finally {
        // 任务完成后计数减一
        latch.countDown();
    }
}

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