The config that was read half-updated

import java.lang.reflect.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;

/**
 * Solution: the config that was read half-updated.
 *
 * The defect was not a missing lock on the reader. It was that a reload
 * MUTATED the object every reader was holding, so there was a window in which
 * the object itself was inconsistent — a v2 endpoint beside a v1 timeout. No
 * amount of synchronizing the readers fixes an object that is briefly wrong.
 *
 * The fix is the one the entry keeps arriving at: never mutate shared state
 * in place. Build a complete, immutable replacement and publish it with a
 * single write across a happens-before edge.
 *
 *   1. Settings becomes immutable — every field final, set in the constructor.
 *      A final field written in a constructor is guaranteed visible, fully
 *      initialised, to any thread that sees the reference. That is the freeze
 *      action, and it is why no lock is needed on the read path.
 *
 *   2. The shared reference becomes volatile, so the write publishing the new
 *      object happens-before every later read of it. One write, one edge, and
 *      everything the constructor did comes across with it.
 *
 *   3. Readers take ONE read of the reference into a local and use that. Two
 *      reads could straddle a reload and reintroduce the mix — this is the
 *      part people leave out, and it is why the local variable is not a style
 *      choice.
 *
 * Cost: an object per reload. Reloads are rare and reads are constant, so this
 * is the right trade — and there is no lock anywhere on the hot path.
 */
public class Solution {

    static final int READERS = 6;
    static final int RELOADS = 40_000;

    static final String[] ENDPOINTS = { "https://api/v1", "https://api/v2", "https://api/v3" };
    static final int[] TIMEOUTS = { 100, 200, 300 };

    /** FIX 1: immutable. Nothing can observe it partly updated, ever. */
    static final class Settings {
        final String endpoint;
        final int timeoutMillis;

        Settings(int version) {
            this.endpoint = ENDPOINTS[version];
            this.timeoutMillis = TIMEOUTS[version];
        }
    }

    /** FIX 2: volatile, so one write publishes the whole object. */
    static volatile Settings settings = new Settings(0);

    public static void main(String[] args) throws Exception {
        boolean ok = true;

        AtomicLong reads = new AtomicLong();
        AtomicLong mixed = new AtomicLong();
        AtomicBoolean stop = new AtomicBoolean(false);

        Thread[] readers = new Thread[READERS];
        for (int i = 0; i < READERS; i++) {
            readers[i] = new Thread(() -> {
                while (!stop.get()) {
                    // FIX 3: one read of the reference, then use the local.
                    Settings s = settings;
                    String endpoint = s.endpoint;
                    int timeout = s.timeoutMillis;
                    reads.incrementAndGet();
                    if (!matches(endpoint, timeout)) mixed.incrementAndGet();
                }
            });
            readers[i].start();
        }

        for (int n = 0; n < RELOADS; n++) {
            settings = new Settings(n % ENDPOINTS.length);
        }
        stop.set(true);
        for (Thread t : readers) t.join();

        System.out.println("── " + RELOADS + " reloads, " + READERS + " concurrent readers ──");
        System.out.println("  reads observed    : " + reads.get());
        System.out.println("  mixed configs     : " + mixed.get());
        System.out.println();

        ok &= check("no reader ever saw a mixed configuration", mixed.get() == 0);
        ok &= check("the settings type is immutable — every field final",
            allFieldsFinal(Settings.class));
        ok &= check("the shared reference is published across a happens-before edge",
            publishedSafely(Solution.class, "settings"));

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    static boolean matches(String endpoint, int timeout) {
        for (int i = 0; i < ENDPOINTS.length; i++) {
            if (ENDPOINTS[i].equals(endpoint)) return TIMEOUTS[i] == timeout;
        }
        return false;
    }

    static boolean allFieldsFinal(Class<?> type) {
        for (Field f : type.getDeclaredFields()) {
            if (!Modifier.isStatic(f.getModifiers()) && !Modifier.isFinal(f.getModifiers())) {
                return false;
            }
        }
        return true;
    }

    static boolean publishedSafely(Class<?> owner, String field) throws Exception {
        int m = owner.getDeclaredField(field).getModifiers();
        return Modifier.isVolatile(m) || Modifier.isFinal(m);
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}