ClassValue 已经缓存了结果，computeValue 为什么还能执行多次？

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ClassValueRaceDemo {
    private static int checks;
    record Token(int number, Class<?> type) {}

    private static void check(boolean ok, String message) {
        if (!ok) throw new AssertionError(message);
        checks++;
    }

    static final class RacingCache extends ClassValue<Token> {
        final AtomicInteger calls = new AtomicInteger();
        final ConcurrentLinkedQueue<Token> made = new ConcurrentLinkedQueue<>();
        final CountDownLatch entered = new CountDownLatch(2);
        final CountDownLatch release = new CountDownLatch(1);

        @Override protected Token computeValue(Class<?> type) {
            int number = calls.incrementAndGet();
            Token token = new Token(number, type);
            made.add(token);
            if (number <= 2) {
                entered.countDown();
                try {
                    if (!release.await(10, TimeUnit.SECONDS))
                        throw new IllegalStateException("compute gate timed out");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    throw new IllegalStateException("compute interrupted", e);
                }
            }
            return token;
        }
    }

    public static void main(String[] args) throws Exception {
        RacingCache cache = new RacingCache();
        ExecutorService pool = Executors.newFixedThreadPool(2);
        Token installed;
        try {
            Future<Token> first = pool.submit(() -> cache.get(String.class));
            Future<Token> second = pool.submit(() -> cache.get(String.class));
            // This controlled OpenJDK experiment needs both computations to enter.
            // A timeout is a failed observation, not a proof about every JVM.
            check(cache.entered.await(5, TimeUnit.SECONDS), "two computations did not enter");
            cache.release.countDown();
            Token a = first.get(5, TimeUnit.SECONDS);
            Token b = second.get(5, TimeUnit.SECONDS);
            List<Token> computed = new ArrayList<>(cache.made);
            check(cache.calls.get() == 2, "controlled race computed twice");
            check(computed.size() == 2 && computed.get(0) != computed.get(1), "two different candidates");
            check(a == b, "racing callers receive the same installed reference");
            check(computed.stream().anyMatch(t -> t == a), "winner is one computed candidate");
            check(a.type() == String.class, "winner belongs to requested class");
            installed = a;
        } finally {
            // Always open the gate, including assertion, timeout and interruption paths.
            cache.release.countDown();
            pool.shutdownNow();
            if (!pool.awaitTermination(5, TimeUnit.SECONDS))
                throw new IllegalStateException("workers did not terminate");
        }
        check(pool.isTerminated(), "executor closed");
        System.out.println("race: computations=2; distinct_candidates=true; same_returned_reference=true; executor_closed=true");

        check(cache.get(String.class) == installed && cache.calls.get() == 2, "later get reuses winner");
        cache.remove(String.class);
        Token refreshed = cache.get(String.class);
        check(refreshed != installed && cache.calls.get() == 3, "remove then get recomputes");
        check(cache.get(String.class) == refreshed && cache.calls.get() == 3, "refreshed value cached");
        Token otherClass = cache.get(Integer.class);
        check(otherClass.type() == Integer.class && otherClass != refreshed && cache.calls.get() == 4,
                "another class has another associated value");
        System.out.println("reuse: before_remove=2; after_remove_get=3; after_other_class_get=4");

        AtomicInteger attempts = new AtomicInteger();
        ClassValue<Token> retry = new ClassValue<>() {
            @Override protected Token computeValue(Class<?> type) {
                int number = attempts.incrementAndGet();
                if (number == 1) throw new IllegalArgumentException("first attempt");
                return new Token(number, type);
            }
        };
        boolean failed = false;
        try { retry.get(String.class); }
        catch (IllegalArgumentException e) { failed = "first attempt".equals(e.getMessage()); }
        check(failed && attempts.get() == 1, "first exception reaches caller");
        Token recovered = retry.get(String.class);
        check(recovered.number() == 2 && attempts.get() == 2, "failure was not cached");
        check(retry.get(String.class) == recovered && attempts.get() == 2, "success then cached");
        System.out.println("failure: first_call=IllegalArgumentException; successful_attempt=2; success_reused=true");
        System.out.println("PASS checks=" + checks + "; controlled_OpenJDK_interleaving_only");
    }
}