MemoryVisibilityDemo.java

// 10. MEMORY VISIBILITY / DATA CORRUPTION - Changes not visible due to caching
// Problem: One thread's changes may not be visible to another due to compiler optimizations
public class MemoryVisibilityDemo {
    static class Flag {
        private boolean flag = false; // NOT volatile!
        private int value = 0;
        
        // Writer thread
        public void writeWithoutVolatile() {
            value = 42;
            flag = true; // Signal that value is ready
            System.out.println("Writer: Set value=42, flag=true");
        }
        
        // Reader thread
        public void readWithoutVolatile() {
            int localValue = 0;
            while (!flag) {
                // Compiler may optimize this away!
                // It might cache flag in a register and never re-read it
            }
            localValue = value;
            System.out.println("Reader: Got value=" + localValue);
        }
    }
    
    static class FlagVolatile {
        private volatile boolean flag = false; // VOLATILE - guarantees visibility
        private volatile int value = 0;
        
        // Writer thread
        public void writeWithVolatile() {
            value = 42;
            flag = true; // Guaranteed to be visible to other threads
            System.out.println("Writer: Set value=42, flag=true (VOLATILE)");
        }
        
        // Reader thread  
        public void readWithVolatile() {
            int localValue = 0;
            while (!flag) {
                // Volatile ensures we re-read flag every time
            }
            localValue = value;
            System.out.println("Reader: Got value=" + localValue + " (VOLATILE)");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("=== WITHOUT VOLATILE ===");
        Flag flagObj = new Flag();
        
        Thread reader1 = new Thread(flagObj::readWithoutVolatile);
        Thread writer1 = new Thread(flagObj::writeWithoutVolatile);
        
        reader1.start();
        Thread.sleep(100);
        writer1.start();
        
        reader1.join();
        writer1.join();
        
        System.out.println("\n=== WITH VOLATILE ===");
        FlagVolatile flagObjVolatile = new FlagVolatile();
        
        Thread reader2 = new Thread(flagObjVolatile::readWithVolatile);
        Thread writer2 = new Thread(flagObjVolatile::writeWithVolatile);
        
        reader2.start();
        Thread.sleep(100);
        writer2.start();
        
        reader2.join();
        writer2.join();
    }
}