高效实现多线程竞速：当一个线程完成时立即终止所有其他线程

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ThreadCoordinationDemo {
    private static final CyclicBarrier barrier = new CyclicBarrier(5);
    private static volatile boolean threadsOver = false;

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            new Thread(new Worker(i)).start();
        }
    }

    static class Worker implements Runnable {
        private final int id;

        public Worker(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            try {
                System.out.println("Thread " + id + " waiting at barrier.");
                barrier.await(); // 等待所有线程就绪
                doSomething();
            } catch (InterruptedException | BrokenBarrierException e) {
                Thread.currentThread().interrupt();
                System.err.println("Thread " + id + " interrupted or barrier broken: " + e.getMessage());
            }
        }

        public void doSomething() {
            long startTime = System.nanoTime();
            // 模拟不确定时长的任务
            while ((System.nanoTime() - startTime < (id + 1) * 10_000_000) && !threadsOver) {
                // 执行一些操作
                // System.out.println("Thread " + id + " working..."); // 调试用
                try {
                    Thread.sleep(1); // 模拟耗时操作，减少CPU空转
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }

            // 如果当前线程完成时，其他线程尚未结束，则表明我是第一个完成的
            if (!threadsOver) {
                System.out.println("Thread " + id + " finished FIRST and setting threadsOver to true.");
                threadsOver = true; // 通知其他线程停止
            } else {
                System.out.println("Thread " + id + " finished LATER, threadsOver was already true.");
            }
        }
    }
}

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

public class InvokeAnyExample {

    public static void main(String[] args) {
        // 创建一个固定大小的线程池，大小与任务数量一致
        ExecutorService executorService = new ThreadPoolExecutor(
                5, 5, 0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>()
        );

        List<Callable<String>> callables = new ArrayList<>();

        // 创建5个Callable任务，每个任务模拟不同的执行时间
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            callables.add(() -> {
                long sleepTime = (long) (Math.random() * 1000 + 500); // 随机睡眠 500ms 到 1500ms
                System.out.println("任务 " + taskId + " 开始执行，预计耗时 " + sleepTime + "ms");
                try {
                    TimeUnit.MILLISECONDS.sleep(sleepTime);
                    // 模拟任务可能抛出异常的情况
                    if (taskId == 3 && Math.random() < 0.3) { // 任务3有30%的概率失败
                        throw new RuntimeException("任务 " + taskId + " 模拟失败！");
                    }
                } catch (InterruptedException e) {
                    System.out.println("任务 " + taskId + " 被中断。");
                    Thread.currentThread().interrupt(); // 重新设置中断状态
                    return "任务 " + taskId + " 被中断并退出。";
                }
                System.out.println("任务 " + taskId + " 完成。");
                return "任务 " + taskId + " 成功完成，耗时 " + sleepTime + "ms。";
            });
        }

        try {
            System.out.println("提交所有任务，等待第一个结果...");
            // invokeAny会返回第一个成功完成的任务的结果
            String result = executorService.invokeAny(callables);
            System.out.println("\n第一个完成任务的结果是: " + result);
        } catch (InterruptedException e) {
            System.err.println("主线程被中断: " + e.getMessage());
            Thread.currentThread().interrupt();
        } catch (ExecutionException e) {
            System.err.println("所有任务均失败或发生异常: " + e.getCause().getMessage());
        } finally {
            // 务必关闭ExecutorService，释放资源
            executorService.shutdownNow(); // 尝试立即停止所有正在执行的任务
            System.out.println("ExecutorService 已关闭。");
        }
    }
}