如何让for循环内的void方法以async方式执行并等待全部完成

以下是几种适配不同场景的实现方案，帮你把同步循环的耗时任务改成异步执行，并在所有任务完成后调用printFinalMessage()。

方法1：使用CompletableFuture（Java 8+ 推荐） #

这是Java 8及以上版本最简洁的实现方式，利用CompletableFuture的异步能力和allOf方法统一等待所有任务完成：

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

// 假设你的list是List<Integer>类型
List<Integer> list = ...;

// 创建自定义线程池（避免使用默认ForkJoinPool，防止资源耗尽）
ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

// 将每个doStuff调用包装为异步任务并收集
CompletableFuture<?>[] asyncTasks = list.stream()
    .map(ele -> CompletableFuture.runAsync(() -> doStuff(ele), executor))
    .toArray(CompletableFuture[]::new);

// 等待所有异步任务完成后执行printFinalMessage
CompletableFuture.allOf(asyncTasks)
    .thenRun(() -> {
        printFinalMessage();
        executor.shutdown(); // 必须关闭线程池释放资源
    })
    .join(); // 如果需要阻塞当前线程等待完成，可根据业务场景选择是否添加

补充说明： #

• 异常处理：如果需要捕获单个任务的异常，可在runAsync的逻辑中添加try-catch，或者在allOf之后用handle统一处理：

  CompletableFuture.allOf(asyncTasks)
      .handle((result, throwable) -> {
          if (throwable != null) {
              // 处理全局异常，比如打印日志
              throwable.printStackTrace();
          }
          printFinalMessage();
          executor.shutdown();
          return null;
      })
      .join();
  

• 线程池配置：IO密集型任务可设置更大的线程数，CPU密集型任务建议和CPU核心数一致，避免线程切换开销。

方法2：使用ExecutorService + CountDownLatch（兼容Java 8以下） #

如果项目基于Java 8之前的版本，可以用CountDownLatch实现等待逻辑：

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

List<Integer> list = ...;
ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// 初始化计数器为列表元素数量
CountDownLatch latch = new CountDownLatch(list.size());

for (int ele : list) {
    executor.submit(() -> {
        try {
            doStuff(ele);
        } finally {
            // 无论任务成功失败，都要减少计数器
            latch.countDown();
        }
    });
}

try {
    // 阻塞当前线程，直到所有任务完成（计数器归0）
    latch.await();
} catch (InterruptedException e) {
    // 恢复线程中断状态，避免丢失中断信号
    Thread.currentThread().interrupt();
}

printFinalMessage();
executor.shutdown();

方法3：Spring环境下使用@Async注解 #

如果是Spring项目，可以通过@Async注解快速实现方法异步化：

1. 首先在配置类上开启异步支持：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
}

2. 将doStuff包装为异步方法（返回CompletableFuture以便跟踪任务状态）：

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import java.util.concurrent.CompletableFuture;

@Component
public class AsyncTaskService {

    @Async
    public CompletableFuture<Void> asyncDoStuff(int ele) {
        doStuff(ele);
        return CompletableFuture.completedFuture(null);
    }
}

3. 在业务代码中调用并等待所有任务完成：

import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

// 注入AsyncTaskService
private final AsyncTaskService asyncTaskService;

// 业务逻辑方法
public void processList(List<Integer> list) {
    List<CompletableFuture<Void>> futures = list.stream()
        .map(asyncTaskService::asyncDoStuff)
        .collect(Collectors.toList());

    // 等待所有异步任务完成
    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
    printFinalMessage();
}

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