Java循环内线程池submit调用get无多线程加速效果原因及优化方案

你当前代码的问题非常明确：在for循环内提交异步任务后，立刻调用Future.get()方法。这个方法会阻塞当前主线程，直到本次提交的远程调用返回结果后，才会进入下一轮循环提交下一个任务。
这种写法同一时间永远只有1个远程请求在执行，和直接在循环里串行调用remoteCall没有任何区别，甚至因为线程创建、上下文切换的额外开销，性能比纯串行还差。

要真正实现并行加速，只需要遵循一个原则：先把所有异步任务全部提交到线程池，持有所有任务的返回句柄后，再统一等待结果、组装数据。
这种模式下，所有远程调用会在提交阶段就开始并行执行，总耗时等于所有请求中最慢的那一个的执行时间，而不是所有请求耗时的累加。
几个生产环境必须注意的点：

• 不要使用Executors.newCachedThreadPool()这类无界参数的线程池，高并发场景下会因为创建过多线程导致OOM，必须自定义线程池的核心线程数、队列长度、饱和策略
• 并发数要根据下游接口的承载能力设置，不要一次性提交成百上千个请求把下游服务打挂
• 组装结果时要注意和入参ID的映射关系，避免结果和ID错位

会，问题本质和语言无关，和编码逻辑有关。
如果你在循环里对每个异步任务直接写await remoteCall(id)，效果和你现在Java的写法完全一致，是串行执行。
这两类语言的正确并行写法和Java逻辑完全对齐：

• C#：先通过Select把所有异步任务投影为Task集合，再调用await Task.WhenAll(任务集合)等待所有任务完成后统一取结果
• JS：先把所有异步任务返回的Promise存入数组，再调用await Promise.all(promise数组)等待所有结果返回，才能实现并行加速

首先建议把线程池定义为Spring容器管理的单例Bean，不要每次调用方法都新建线程池：

import java.util.concurrent.*;

// 线程池参数根据实际业务场景、下游承载能力调整
private final ThreadPoolExecutor bizExecutor = new ThreadPoolExecutor(
        8,
        16,
        60L,
        TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(100),
        new ThreadPoolExecutor.CallerRunsPolicy()
);

基础Future实现版本 #

public List<ResultDto> queryAll(List<String> ids) throws ExecutionException, InterruptedException {
    // 第一步：批量提交所有异步任务，建立ID和任务的映射
    Map<String, Future<String>> idTaskMap = new HashMap<>(ids.size());
    for (String id : ids) {
        Future<String> remoteTask = bizExecutor.submit(() -> remoteCall(id));
        idTaskMap.put(id, remoteTask);
    }

    // 第二步：所有任务已经在并行执行，统一获取结果组装返回
    List<ResultDto> resultList = new ArrayList<>(ids.size());
    for (String id : ids) {
        BaseData baseData = new BaseData();
        baseData.setBaseInfo("baseData" + id);
        // 这里get只会等待尚未执行完成的任务，已完成的任务会立刻返回结果
        baseData.setRemoteInfo(idTaskMap.get(id).get());
        ResultDto dto = new ResultDto();
        dto.setBaseData(baseData);
        resultList.add(dto);
    }
    return resultList;
}

private String remoteCall(String id) {
    return " httpUtils.get()" + id;
}

CompletableFuture简化版本（推荐） #

JDK8之后提供的CompletableFuture写法更简洁，还支持自定义异常降级、任务编排，更适合业务场景：

public List<ResultDto> queryAllCompletable(List<String> ids) {
    // 批量提交异步任务
    List<CompletableFuture<ResultDto>> allTasks = ids.stream()
            .map(id -> CompletableFuture.supplyAsync(() -> {
                BaseData baseData = new BaseData();
                baseData.setBaseInfo("baseData" + id);
                baseData.setRemoteInfo(remoteCall(id));
                ResultDto dto = new ResultDto();
                dto.setBaseData(baseData);
                return dto;
            }, bizExecutor)) // 务必使用自定义业务线程池，不要用公共ForkJoinPool
            .toList();

    // 等待所有任务完成，收集结果
    return allTasks.stream()
            .map(CompletableFuture::join)
            .toList();
}

如果业务对并发数控制要求更高，可以搭配Semaphore在remoteCall方法内部做限流，避免突发流量冲垮下游服务。

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