乐观读已经验证成功，为什么接着读还是会拼出错配数据？

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.StampedLock;

public final class Main {
    private static int checks;
    private static final class Pair {
        final StampedLock lock = new StampedLock();
        int x = 10;
        int y = 20;
    }
    private static void check(boolean ok, String message) {
        checks++;
        if (!ok) throw new AssertionError(message);
    }
    private static void await(CountDownLatch latch) throws InterruptedException {
        if (!latch.await(5, TimeUnit.SECONDS)) throw new AssertionError("Coordination timed out");
    }
    private static void writeOnWorker(Pair pair, int nextX) throws Exception {
        CountDownLatch start = new CountDownLatch(1);
        CountDownLatch done = new CountDownLatch(1);
        AtomicReference<Throwable> error = new AtomicReference<>();
        Thread worker = new Thread(() -> {
            try {
                await(start);
                long stamp = pair.lock.writeLock();
                try {
                    pair.x = nextX;
                    pair.y = 2 * nextX;
                } finally {
                    pair.lock.unlockWrite(stamp);
                }
            } catch (Throwable failure) {
                error.set(failure);
            } finally {
                done.countDown();
            }
        }, "controlled-writer");
        worker.start();
        start.countDown();
        try {
            await(done);
        } finally {
            worker.join(5000);
            if (worker.isAlive()) {
                worker.interrupt();
                throw new AssertionError("Worker did not finish");
            }
        }
        if (error.get() != null) throw new AssertionError(error.get());
    }
    private static int[] readLocked(Pair pair) {
        long stamp = pair.lock.readLock();
        try {
            return new int[]{pair.x, pair.y};
        } finally {
            pair.lock.unlockRead(stamp);
        }
    }
    public static void main(String[] args) throws Exception {
        Pair pair = new Pair();
        long stamp = pair.lock.tryOptimisticRead();
        check(stamp != 0L, "optimistic read starts while no writer holds the lock");
        int oldX = pair.x;
        writeOnWorker(pair, 30);
        int newY = pair.y;
        boolean valid = pair.lock.validate(stamp);
        check(oldX == 10 && newY == 60, "controlled interleaving produces a mixed candidate");
        check(!valid, "write lock invalidates the earlier stamp");
        check(newY != 2 * oldX, "candidate is not a consistent pair");
        int[] accepted = valid ? new int[]{oldX, newY} : readLocked(pair);
        check(accepted[0] == 30 && accepted[1] == 60, "fallback rereads every field under read lock");
        System.out.println("interleaved: candidate=" + oldX + "," + newY
                + "; valid=" + valid + "; accepted=" + accepted[0] + "," + accepted[1]);

        stamp = pair.lock.tryOptimisticRead();
        int localX = pair.x;
        int localY = pair.y;
        boolean acceptedBeforeLaterWrite = pair.lock.validate(stamp);
        check(acceptedBeforeLaterWrite, "read-then-validate succeeds without an intervening writer");
        check(localY == 2 * localX, "accepted local values form a pair");
        writeOnWorker(pair, 40);
        check(localX == 30 && localY == 60, "later write cannot change captured primitive locals");
        check(!pair.lock.validate(stamp), "old stamp is invalid after a subsequent writer");
        System.out.println("accepted-snapshot: valid-at-read=" + acceptedBeforeLaterWrite
                + "; locals=" + localX + "," + localY + "; current=" + pair.x + "," + pair.y);

        stamp = pair.lock.tryOptimisticRead();
        boolean checkedTooEarly = pair.lock.validate(stamp);
        int earlyX = pair.x;
        writeOnWorker(pair, 50);
        int lateY = pair.y;
        check(checkedTooEarly, "validation before reading can return true");
        check(earlyX == 40 && lateY == 100 && lateY != 2 * earlyX, "later reads are not covered by early check");
        check(!pair.lock.validate(stamp), "a final validation rejects the later mixed reads");
        System.out.println("check-before-read: early-valid=" + checkedTooEarly
                + "; later-candidate=" + earlyX + "," + lateY
                + "; final-valid=" + pair.lock.validate(stamp));

        long writeStamp = pair.lock.writeLock();
        long unavailable;
        try {
            unavailable = pair.lock.tryOptimisticRead();
            check(unavailable == 0L, "writer-held lock yields zero optimistic stamp");
            check(!pair.lock.validate(unavailable), "zero stamp is invalid");
        } finally {
            pair.lock.unlockWrite(writeStamp);
        }
        check(!pair.lock.isWriteLocked(), "writer lock was released");
        int[] finalPair = readLocked(pair);
        check(finalPair[1] == 2 * finalPair[0], "final locked read is consistent");
        System.out.println("writer-held: optimistic-stamp=" + unavailable + "; valid=false");
        System.out.println("PASS " + checks);
    }
}