Java：如何获取最快完成且返回非空结果的任务返回值？

这个需求其实是典型的竞赛式任务执行场景——让多个算法同时跑，抢第一个给出有效结果的，然后立刻叫停剩下的任务。我给你写一个Java的完整实现，完全贴合你的要求：

• 用ExecutorService线程池来统一管理三个任务的线程，方便后续批量终止任务
• 每个任务必须支持响应中断：因为要终止未完成的任务，所以任务里的耗时操作必须能检测到中断信号并及时退出
• 用CompletableFuture监听每个任务的执行结果，一旦捕获到第一个非空的有效结果，立刻触发线程池关闭，中断所有未完成的任务
• 兜底处理所有任务都返回空的情况

首先是模拟的A、B、C三个类（每个类的算法耗时和返回逻辑不同）：

// 类A：中等耗时，仅当搜索词为"test"时返回结果
class A {
    public String search(String toSearch) throws InterruptedException {
        // 模拟耗时操作，每步检查中断状态
        for (int i = 0; i < 500; i++) {
            if (Thread.currentThread().isInterrupted()) {
                return null; // 被中断，直接返回空
            }
            Thread.sleep(1);
        }
        return toSearch.equals("test") ? "Result from Algorithm A" : null;
    }
}

// 类B：最快完成，始终返回结果
class B {
    public String search(String toSearch) throws InterruptedException {
        Thread.sleep(100); // 模拟短耗时计算
        if (Thread.currentThread().isInterrupted()) {
            return null;
        }
        return "Result from Algorithm B";
    }
}

// 类C：最慢完成，仅当搜索词为"slow"时返回结果
class C {
    public String search(String toSearch) throws InterruptedException {
        Thread.sleep(1000); // 模拟长耗时计算
        if (Thread.currentThread().isInterrupted()) {
            return null;
        }
        return toSearch.equals("slow") ? "Result from Algorithm C" : null;
    }
}

然后是主类Main的search方法实现：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Main {
    private final A algorithmA = new A();
    private final B algorithmB = new B();
    private final C algorithmC = new C();

    public String search(String toSearch) throws InterruptedException, ExecutionException {
        // 创建固定大小的线程池，刚好容纳三个任务
        ExecutorService executor = Executors.newFixedThreadPool(3);
        List<CompletableFuture<String>> taskFutures = new ArrayList<>();

        // 包装每个算法的任务，统一处理异常
        taskFutures.add(CompletableFuture.supplyAsync(() -> {
            try {
                return algorithmA.search(toSearch);
            } catch (Exception e) {
                return null;
            }
        }, executor));

        taskFutures.add(CompletableFuture.supplyAsync(() -> {
            try {
                return algorithmB.search(toSearch);
            } catch (Exception e) {
                return null;
            }
        }, executor));

        taskFutures.add(CompletableFuture.supplyAsync(() -> {
            try {
                return algorithmC.search(toSearch);
            } catch (Exception e) {
                return null;
            }
        }, executor));

        // 用于接收第一个有效结果的Future
        CompletableFuture<String> firstValidResult = new CompletableFuture<>();

        // 给每个任务添加结果监听
        for (CompletableFuture<String> future : taskFutures) {
            future.thenAccept(result -> {
                // 只处理第一个非空结果
                if (result != null && !firstValidResult.isDone()) {
                    firstValidResult.complete(result);
                    // 立刻关闭线程池，中断所有未完成的任务
                    executor.shutdownNow();
                }
            });
        }

        // 等待第一个有效结果，或者所有任务完成
        CompletableFuture<Void> allTasksDone = CompletableFuture.allOf(taskFutures.toArray(new CompletableFuture[0]));
        CompletableFuture.anyOf(firstValidResult, allTasksDone).get();

        // 返回结果：如果有有效结果就返回，否则返回null
        return firstValidResult.isDone() ? firstValidResult.get() : null;
    }

    public static void main(String[] args) throws Exception {
        Main main = new Main();
        String result = main.search("test");
        System.out.println("最终结果：" + result);
        // 输出应为 "最终结果：Result from Algorithm B"，因为B最快完成
    }
}

1. 线程中断的必要性：
   每个算法的search方法里都检查了Thread.currentThread().isInterrupted()，这是因为executor.shutdownNow()会给所有正在执行的线程发送中断信号。如果你的算法里有阻塞调用（比如Thread.sleep、IO操作），这些方法会直接抛出InterruptedException，捕获后返回null即可终止任务。

2. 线程池的关闭策略：
   使用shutdownNow()而不是shutdown()，因为前者会主动中断所有未完成的任务，而后者只是拒绝新任务，等待现有任务完成，不符合“立即终止其余任务”的要求。

3. 避免无限阻塞：
   用CompletableFuture.anyOf(firstValidResult, allTasksDone)来等待，既可以拿到第一个有效结果，也能在所有任务都返回空时及时结束，不会一直阻塞。

4. 异常处理：
   每个任务的异常都被捕获并返回null，避免单个任务的异常导致整个流程崩溃。

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