只有一个线程等超时，为什么其他线程也一起失败？

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;

public final class Main {
    private static int checks;
    private static void check(boolean ok, String message) {
        checks++;
        if (!ok) throw new AssertionError(message);
    }
    private static void awaitLatch(CountDownLatch latch) throws InterruptedException {
        if (!latch.await(5, TimeUnit.SECONDS)) throw new AssertionError("Coordination timed out");
    }
    private static String attempt(CyclicBarrier barrier, long timeout, TimeUnit unit) {
        try {
            barrier.await(timeout, unit);
            return "OK";
        } catch (Exception failure) {
            return failure.getClass().getSimpleName();
        }
    }
    private static Thread waitingWorker(CyclicBarrier barrier, AtomicReference<String> result,
                                        CountDownLatch entered) {
        Thread worker = new Thread(() -> {
            entered.countDown();
            result.set(attempt(barrier, 5, TimeUnit.SECONDS));
        }, "barrier-waiter");
        worker.start();
        return worker;
    }
    private static void confirmWaiting(CyclicBarrier barrier, CountDownLatch entered) throws Exception {
        awaitLatch(entered);
        long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(3);
        while (barrier.getNumberWaiting() != 1) {
            if (System.nanoTime() - deadline >= 0) throw new AssertionError("Waiter did not reach barrier");
            Thread.onSpinWait();
        }
        check(barrier.getNumberWaiting() == 1, "one worker is already waiting");
    }
    private static void join(Thread worker) throws InterruptedException {
        worker.join(5000);
        if (worker.isAlive()) {
            worker.interrupt();
            throw new AssertionError("Worker did not finish");
        }
    }
    public static void main(String[] args) throws Exception {
        AtomicInteger rounds = new AtomicInteger();
        CyclicBarrier barrier = new CyclicBarrier(3, rounds::incrementAndGet);
        AtomicReference<String> waitingResult = new AtomicReference<>();
        CountDownLatch entered = new CountDownLatch(1);
        Thread waiting = waitingWorker(barrier, waitingResult, entered);
        confirmWaiting(barrier, entered);
        // Only two of three parties can arrive; zero timeout deliberately breaks this round.
        String timeoutResult = attempt(barrier, 0, TimeUnit.NANOSECONDS);
        join(waiting);
        check(timeoutResult.equals("TimeoutException"), "the timeout initiator gets TimeoutException");
        check(waitingResult.get().equals("BrokenBarrierException"), "existing waiter sees broken round");
        check(barrier.isBroken(), "barrier remains broken");
        check(rounds.get() == 0, "incomplete round never runs the action");
        String late = attempt(barrier, 0, TimeUnit.NANOSECONDS);
        check(late.equals("BrokenBarrierException"), "late arrival sees existing broken state");
        System.out.println("timeout-round: initiator=" + timeoutResult + "; waiter="
                + waitingResult.get() + "; late=" + late + "; broken=" + barrier.isBroken());

        // Old participants have ended before the coordinator starts a fresh generation.
        barrier.reset();
        check(!barrier.isBroken() && barrier.getNumberWaiting() == 0, "reset starts a fresh generation");
        CountDownLatch ready = new CountDownLatch(3);
        CountDownLatch start = new CountDownLatch(1);
        AtomicReference<Throwable> workerError = new AtomicReference<>();
        List<List<Integer>> indexes = List.of(
                Collections.synchronizedList(new ArrayList<>()),
                Collections.synchronizedList(new ArrayList<>()));
        List<Thread> workers = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            Thread worker = new Thread(() -> {
                try {
                    ready.countDown();
                    awaitLatch(start);
                    for (int round = 0; round < 2; round++) {
                        indexes.get(round).add(barrier.await(5, TimeUnit.SECONDS));
                    }
                } catch (Throwable failure) {
                    workerError.compareAndSet(null, failure);
                }
            }, "round-worker-" + i);
            workers.add(worker);
            worker.start();
        }
        awaitLatch(ready);
        start.countDown();
        for (Thread worker : workers) join(worker);
        if (workerError.get() != null) throw new AssertionError(workerError.get());
        for (List<Integer> values : indexes) {
            Collections.sort(values);
            check(values.equals(List.of(0, 1, 2)), "each successful round returns all arrival indexes");
        }
        check(rounds.get() == 2, "successful rounds automatically reuse the barrier");
        check(!barrier.isBroken(), "two successful rounds leave barrier healthy");
        System.out.println("after-reset: round1=" + indexes.get(0) + "; round2=" + indexes.get(1)
                + "; actions=" + rounds.get() + "; broken=" + barrier.isBroken());

        CyclicBarrier resetBarrier = new CyclicBarrier(2);
        AtomicReference<String> resetResult = new AtomicReference<>();
        CountDownLatch resetEntered = new CountDownLatch(1);
        Thread resetWaiter = waitingWorker(resetBarrier, resetResult, resetEntered);
        confirmWaiting(resetBarrier, resetEntered);
        resetBarrier.reset();
        join(resetWaiter);
        check(resetResult.get().equals("BrokenBarrierException"), "reset rejects old waiter");
        check(!resetBarrier.isBroken(), "new generation can be healthy while old waiter failed");
        System.out.println("reset-waiting: old-waiter=" + resetResult.get()
                + "; current.broken=" + resetBarrier.isBroken());

        CyclicBarrier failedAction = new CyclicBarrier(2, () -> {
            throw new IllegalStateException("merge failed");
        });
        AtomicReference<String> actionWaiterResult = new AtomicReference<>();
        CountDownLatch actionEntered = new CountDownLatch(1);
        Thread actionWaiter = waitingWorker(failedAction, actionWaiterResult, actionEntered);
        confirmWaiting(failedAction, actionEntered);
        String actionOwnerResult = attempt(failedAction, 5, TimeUnit.SECONDS);
        join(actionWaiter);
        check(actionOwnerResult.equals("IllegalStateException"), "last arrival runs the failing action");
        check(actionWaiterResult.get().equals("BrokenBarrierException"), "other waiter sees broken barrier");
        check(failedAction.isBroken(), "failed action breaks the generation");
        System.out.println("action-failure: runner=" + actionOwnerResult + "; waiter="
                + actionWaiterResult.get() + "; broken=" + failedAction.isBroken());
        System.out.println("PASS " + checks);
    }
}