Java递归遍历CompletableFuture遇栈溢出，如何改为非递归循环？

问题根源 #

递归链式调用CompletableFuture时，若后续任务在前一个任务的完成线程中同步执行（比如默认线程池的同步回调），调用栈会不断累积。当遍历次数达到JVM栈上限（通常约1000次）时，就会触发StackOverflowError。

解决方案：迭代式任务链 #

通过维护一个当前的CompletableFuture实例，在循环中持续将新的异步任务链接到该实例上，避免递归调用栈的累积。同时保留runAffinityFilters的异步非阻塞特性。

基础迭代实现（顺序遍历）

假设原递归代码如下（存在栈溢出风险）：

// 原递归实现，易触发StackOverflowError
private CompletableFuture<Void> processCandidates(List<Candidate> candidates, int index) {
    if (index >= candidates.size()) {
        return CompletableFuture.completedFuture(null);
    }
    Candidate candidate = candidates.get(index);
    return runAffinityFilters(candidate)
        .thenCompose(result -> {
            if (result.isValid()) {
                handleValidCandidate(candidate);
            }
            return processCandidates(candidates, index + 1);
        });
}

修改后的迭代实现：

// 迭代式异步遍历，规避栈溢出
public CompletableFuture<Void> processCandidatesIteratively(List<Candidate> candidates) {
    // 初始化已完成的Future作为任务链起点
    CompletableFuture<Void> currentFuture = CompletableFuture.completedFuture(null);
    
    for (Candidate candidate : candidates) {
        // 捕获当前循环的候选对象，避免闭包引用错误
        Candidate currentCandidate = candidate;
        currentFuture = currentFuture.thenCompose(ignored -> 
            runAffinityFilters(currentCandidate)
                .thenAccept(result -> {
                    if (result.isValid()) {
                        handleValidCandidate(currentCandidate);
                    }
                })
        );
    }
    
    return currentFuture;
}

支持中途终止的迭代实现

如果需要在遍历过程中根据结果终止迭代，可以结合原子索引和异步任务提交实现：

// 支持中途终止的异步遍历
public CompletableFuture<Void> processCandidatesWithTermination(List<Candidate> candidates) {
    AtomicInteger index = new AtomicInteger(0);
    CompletableFuture<Void> resultFuture = new CompletableFuture<>();
    
    Runnable nextTask = () -> {
        int currentIdx = index.getAndIncrement();
        if (currentIdx >= candidates.size()) {
            resultFuture.complete(null);
            return;
        }
        
        Candidate candidate = candidates.get(currentIdx);
        runAffinityFilters(candidate)
            .thenAccept(result -> {
                if (result.isValid()) {
                    handleValidCandidate(candidate);
                    // 继续下一个任务（异步线程中执行，无栈累积）
                    nextTask.run();
                } else {
                    // 终止遍历
                    resultFuture.complete(null);
                }
            })
            .exceptionally(ex -> {
                // 异常终止，传递异常
                resultFuture.completeExceptionally(ex);
                return null;
            });
    };
    
    // 启动第一个任务
    nextTask.run();
    return resultFuture;
}

关键注意事项 #

1. 闭包变量捕获：循环中必须显式捕获当前的Candidate对象，否则闭包会引用循环变量的最终值，导致所有任务处理同一个候选。
2. 异步保证：runAffinityFilters必须是真正的异步非阻塞调用（例如用CompletableFuture.supplyAsync包裹数据库操作，指定独立线程池），确保回调不在调用线程的栈中执行。
3. 任务链维护：通过thenCompose链接任务，保证遍历的顺序性；若无需顺序，可改用CompletableFuture.allOf并行处理后汇总结果。

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