如何使用ExecutorService在独立线程执行HTTP请求并返回响应

现有实现存在以下几个核心问题：

• Callable实现缺少返回值：你在Callable lambda内部调用了executeRequests()但没有将结果返回，同时捕获异常后也没有对应错误结果返回，会导致future.get()拿到空值或者无法感知业务异常
• 线程池选型错误：Executors.newWorkStealingPool()默认线程数等于CPU核心数，适合CPU密集型计算场景，你的业务是循环执行HTTP请求，属于IO密集型任务，该配置会导致大量线程阻塞等待IO，吞吐量极低
• 阻塞调用无意义：当前逻辑直接调用future.get()阻塞等待任务执行完成，和直接在请求线程执行executeRequests()没有本质区别，完全没有用到多线程的优势
• 缺少线程池销毁逻辑：应用关闭时没有主动关闭线程池，会导致线程泄漏

根据业务场景可选择以下两种实现方式：

场景1：需要同步等待任务执行完成后返回结果 #

适合前端可以接受较长等待时间的场景，优化后代码如下：

private ExecutorService executorService;

// 自定义IO密集型线程池，不要用Executors的默认实现
@PostConstruct
public void init() {
    // IO密集型线程数一般设置为CPU核心数2~4倍，可根据压测结果调整
    int coreSize = Runtime.getRuntime().availableProcessors() * 2; 
    executorService = new ThreadPoolExecutor(
            coreSize,
            coreSize * 2,
            60L,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(200), // 队列长度不要设为Integer.MAX_VALUE，避免OOM
            new ThreadFactoryBuilder().setNameFormat("http-request-pool-%d").build() // 给线程命名方便排查问题
    );
}

@Override
public ResponseDto getSummary() throws ExecutionException, InterruptedException, TimeoutException {
    Callable<ResponseDto> task = () -> {
        ResponseDto result = executeRequests();
        log.debug("Fetching summary details completed");
        return result;
    };

    Future<ResponseDto> future = executorService.submit(task);
    // 增加超时时间，避免请求无限挂起，时长根据业务实际执行情况调整
    return future.get(30, TimeUnit.SECONDS);
}

private ResponseDto executeRequests() { 
  // 原有循环执行HTTP请求逻辑，返回ResponseDto
}

// 应用关闭时销毁线程池，避免线程泄漏
@PreDestroy
public void destroy() {
    if (executorService != null) {
        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

场景2：不需要同步等待结果，提交任务后直接返回 #

如果任务执行时间很长，前端不需要实时拿到结果，可以直接返回提交成功的响应，后续通过回调或者轮询的方式获取结果，代码示例：

@Override
public String submitSummaryTask() {
    // 生成唯一任务ID存入缓存，用于后续查询结果
    String taskId = UUID.randomUUID().toString();
    executorService.submit(() -> {
        try {
            ResponseDto result = executeRequests();
            // 结果存入缓存，key为taskId，设置过期时间
            cache.put(taskId, result, 1, TimeUnit.HOURS);
            log.debug("Task {} completed", taskId);
        } catch (Exception e) {
            log.error("Task {} failed", taskId, e);
            // 错误信息也存入缓存，方便前端查询
            cache.put(taskId, "执行失败：" + e.getMessage(), 1, TimeUnit.HOURS);
        }
    });
    return taskId;
}

// 额外提供查询任务结果的接口
public Object getTaskResult(String taskId) {
    return cache.getOrDefault(taskId, "任务执行中");
}

该场景下完全不会阻塞当前请求线程，适合耗时较长的批量HTTP请求场景。

• 循环中的HTTP请求可以再拆分为多个子任务提交到线程池并行执行，进一步缩短总执行时间
• 为HTTP请求设置独立的超时时间，避免单个请求阻塞整个循环
• 增加失败重试机制，提升HTTP请求的成功率

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