如何让每个Promise以异步方式耗时2秒完成？（Vertx代码优化）

原代码的核心问题是在主线程中逐个同步执行Thread.sleep(2000)，导致总耗时是2秒×数字个数，完全没利用异步并行的优势。下面是修改后的代码，让每个Promise的完成逻辑在独立线程中异步执行，所有任务可并行完成，总耗时约2秒而非逐个累加：

import io.vertx.core.CompositeFuture;
import io.vertx.core.Future;
import io.vertx.core.Promise;
import io.vertx.core.json.JsonArray;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class Task {
    // 改为返回Future<Integer>，契合Vert.x异步编程范式
    public static Future<Integer> sumEven(JsonArray numbers) {
        List<Future<Integer>> futures = new ArrayList<>();
        
        for (int i = 0; i < numbers.size(); i++) {
            int num = numbers.getInteger(i);
            Promise<Integer> promise = Promise.promise();
            
            // 启动独立线程处理单个任务
            new Thread(() -> {
                try {
                    Thread.sleep(2000);
                    System.out.println("完成数字处理: " + num);
                    promise.complete(num);
                } catch (InterruptedException e) {
                    System.out.println("线程被中断");
                    promise.fail(e);
                }
            }).start();
            
            futures.add(promise.future());
        }
        
        // 用CompositeFuture等待所有Future完成，避免阻塞调用result()
        return CompositeFuture.all(futures)
                .compose(v -> {
                    // 过滤偶数并求和
                    int sum = futures.stream()
                            .map(Future::result)
                            .filter(n -> n % 2 == 0)
                            .mapToInt(Integer::intValue)
                            .sum();
                    return Future.succeededFuture(sum);
                })
                .recover(e -> {
                    // 统一处理异常，返回0或按需调整
                    System.err.println("处理过程出错: " + e.getMessage());
                    return Future.succeededFuture(0);
                });
    }

    // 示例调用
    public static void main(String[] args) {
        JsonArray numbers = new JsonArray().add(1).add(2).add(3).add(4);
        sumEven(numbers).onSuccess(sum -> System.out.println("偶数总和: " + sum))
                        .onFailure(e -> System.err.println("调用失败: " + e.getMessage()));
        
        // 主线程暂不退出，等待异步任务完成
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

关键改动说明： #

• 异步线程执行任务：把每个数字的处理逻辑（sleep+完成Promise）放到独立线程启动，所有任务并行执行，总耗时约2秒。
• 用CompositeFuture管理多Future：替代原代码中直接阻塞获取result()的方式，符合Vert.x非阻塞异步原则，同时统一处理所有任务的完成/失败状态。
• 方法返回Future：异步操作不应直接返回同步结果，返回Future让调用方通过onSuccess/onFailure异步处理结果，避免主线程阻塞。
• 异常兜底处理：通过recover方法统一捕获任务执行中的异常，保证方法健壮性。

如果确实需要同步返回结果（不推荐，违背异步设计初衷），可以在调用时用Future.toCompletionStage().toCompletableFuture().get()阻塞等待，但会丢失异步并行的优势。

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