Java Memory Model (JMM)

// Classic visibility bug (may loop forever)
class BrokenStop {
    static boolean stop = false; // no volatile

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (!stop) {} // JIT may hoist 'stop' read out of the loop
            System.out.println("stopped");
        }).start();

        Thread.sleep(100);
        stop = true; // write may never be flushed to main memory
                     // or the reader thread may never see it
    }
}

// Why this can fail:
// 1. JIT compiler can cache 'stop' in a register (loop invariant hoisting)
// 2. CPU write buffer may not flush to main memory
// 3. Reader CPU cache may not invalidate its cached copy

// Fix: declare stop as volatile — establishes happens-before

// Happens-before through volatile
volatile int flag = 0;
int data = 0;

// Thread A
data = 42;       // (1)
flag = 1;        // (2) volatile write

// Thread B
if (flag == 1) { // (3) volatile read — HB guarantees (2) is visible
    // (3) HB (2) because volatile read sees the volatile write
    // (2) HB in program order, so (1) HB (2)
    // Transitivity: (1) HB (3) → data is guaranteed to be 42
    System.out.println(data); // ALWAYS 42, not 0
}

// Happens-before through synchronized
Object lock = new Object();
int value = 0;

// Thread A
synchronized(lock) { value = 100; } // unlock HB next lock

// Thread B
synchronized(lock) {
    // lock HB unlock in Thread A → value is guaranteed 100
    System.out.println(value);
}

// UNSAFE publication — other threads may see partial state
class UnsafeHolder {
    public Object value;
    public UnsafeHolder() { value = new HeavyObject(); }
}
static UnsafeHolder holder; // non-volatile, non-final
// Thread A: holder = new UnsafeHolder()
// Thread B: holder.value — may see null (JIT reordering of stores)

// SAFE publication via volatile
static volatile UnsafeHolder safeHolder;

// SAFE via final — JMM special guarantee
class ImmutablePoint {
    final int x, y;
    ImmutablePoint(int x, int y) { this.x = x; this.y = y; }
    // Any thread seeing a reference to an ImmutablePoint is
    // GUARANTEED to see the final fields as set in the constructor
}

// SAFE via static initialiser — class init is synchronized by JVM
static final ImmutablePoint ORIGIN = new ImmutablePoint(0, 0);

// SAFE via concurrent collection
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
map.put("key", new HeavyObject()); // publication is safe