Java 메모리 모델 — happens-before와 가시성의 진짜 의미

┌──────────┐    ┌──────────┐    ┌──────────┐
│  Thread 1 │    │  Thread 2 │    │  Thread 3 │
└────┬─────┘    └────┬─────┘    └────┬─────┘
     │               │               │
┌────▼─────┐    ┌────▼─────┐    ┌────▼─────┐
│ CPU 캐시  │    │ CPU 캐시  │    │ CPU 캐시  │
│  (L1/L2) │    │  (L1/L2) │    │  (L1/L2) │
└────┬─────┘    └────┬─────┘    └────┬─────┘
     │               │               │
     └───────────────┼───────────────┘
                     │
              ┌──────▼──────┐
              │   메인 메모리  │
              └─────────────┘

public class VisibilityProblem {
    private boolean running = true; // 일반 변수 — 가시성 보장 없음

    public void stop() {
        running = false; // Thread 1이 변경
    }

    public void run() {
        while (running) { } // Thread 2 — 영원히 안 끝날 수 있다
        System.out.println("종료됨");
    }
}

synchronized (lock) { x = 10; }   // Thread 1 — unlock
synchronized (lock) { print(x); } // Thread 2 — lock → x == 10 보장

volatile boolean ready = false;
int data = 0;

// Thread 1
data = 42;         // 일반 쓰기
ready = true;      // volatile 쓰기

// Thread 2
if (ready) {       // volatile 읽기
    print(data);   // 반드시 42 — ready의 happens-before 덕분에 data도 보임
}

public class VolatileExample {
    private volatile boolean flag = false;
    private int data = 0;

    public void writer() {
        data = 42;        // (1) 일반 쓰기
        flag = true;      // (2) volatile 쓰기 — (1)이 메인 메모리에 반영됨
    }

    public void reader() {
        if (flag) {       // (3) volatile 읽기
            // data == 42 보장 — (2) happens-before (3)
            System.out.println(data);
        }
    }
}

private volatile int count = 0;

public void increment() {
    count++; // read(0) → modify(1) → write(1) — 세 단계라 원자적이지 않다!
    // 두 스레드가 동시에 read(0)을 하면 둘 다 1을 쓴다 → 결과: 1 (기대값 2)
}

synchronized (monitor) {
    // ── lock 획득 (acquire barrier) ──
    // 메인 메모리에서 최신 값을 읽어온다
    sharedData = 42;
    // ── unlock (release barrier) ──
    // 모든 변경사항을 메인 메모리에 반영한다
}

// volatile — 개별 변수의 가시성만 보장, 원자성 없음
private volatile int x;
private volatile int y;
x = 1;  // 다른 스레드가 여기서 읽으면 x=1, y=0 상태를 볼 수 있다
y = 2;

// synchronized — 블록 안의 모든 변수에 대해 원자성 + 가시성 보장
synchronized (lock) {
    x = 1;
    y = 2;
    // 다른 스레드는 (x=0, y=0) 또는 (x=1, y=2) 중 하나만 본다
}

public class ImmutableConfig {
    private final int timeout;
    private final String host;

    public ImmutableConfig(int timeout, String host) {
        this.timeout = timeout;
        this.host = host;
    }
    // 생성자 완료 후, 어떤 스레드에서든 timeout과 host 값이 보장된다
}

public class Broken {
    private final int value;
    public Broken() {
        SomeRegistry.register(this); // 위험! 생성자 끝나기 전에 this 누출
        value = 42;
    }
}

public class BrokenSingleton {
    private static BrokenSingleton instance; // volatile 아님!

    public static BrokenSingleton getInstance() {
        if (instance == null) {                       // (1) 락 밖에서 체크
            synchronized (BrokenSingleton.class) {
                if (instance == null) {               // (2) 락 안에서 체크
                    instance = new BrokenSingleton(); // (3) 문제 지점
                }
            }
        }
        return instance;
    }
}

1. 메모리 할당
3. instance에 참조 대입  ← 먼저!
2. 생성자 실행           ← 아직 안 끝남

public class Singleton {
    private static volatile Singleton instance; // volatile이 재배치 방지

    public static Singleton getInstance() {
        Singleton localRef = instance; // volatile 읽기 횟수 줄이기
        if (localRef == null) {
            synchronized (Singleton.class) {
                localRef = instance;
                if (localRef == null) {
                    instance = localRef = new Singleton();
                }
            }
        }
        return localRef;
    }
}

public class Singleton {
    private Singleton() {}

    // 내부 클래스는 처음 참조될 때 로딩 — 클래스 로딩 자체가 스레드 안전
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

  쓰기 A, 쓰기 B
  ─── Store Barrier ───  ← 이 위의 쓰기가 아래로 내려갈 수 없음
  volatile 쓰기

  volatile 읽기
  ─── Load Barrier ────  ← 이 아래의 읽기가 위로 올라갈 수 없음
  읽기 A, 읽기 B

하나의 변수만 관련?
├── YES → 단순 읽기/쓰기? → volatile
│         복합 연산(read-modify-write)? → AtomicInteger 등
└── NO → 여러 변수의 일관성 필요? → synchronized (또는 Lock)

// 1. volatile — 상태 플래그
private volatile boolean shutdown = false;
public void shutdown() { shutdown = true; }
public void doWork() {
    while (!shutdown) { /* 작업 */ }
}

// 2. synchronized — 불변 조건 보호 (체크와 반영이 원자적이어야 함)
private int balance = 0;
public synchronized void transfer(int amount) {
    if (balance >= amount) { balance -= amount; }
}

// 3. AtomicInteger — 단순 카운터
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
    count.incrementAndGet(); // CAS 기반 원자적 증가
}

// 잘못된 코드 — 무한 루프에 빠질 수 있다
public class StopThread {
    private boolean stopRequested = false; // volatile 아님

    public static void main(String[] args) throws InterruptedException {
        StopThread st = new StopThread();
        Thread worker = new Thread(() -> {
            int i = 0;
            while (!st.stopRequested) { i++; }
        });
        worker.start();
        Thread.sleep(1000);
        st.stopRequested = true; // worker에 안 보일 수 있다
    }
}

private volatile boolean stopRequested = false;

// 잘못된 코드 — volatile은 복합 연산을 보호하지 못한다
private volatile int nextId = 0;
public int generateId() {
    return nextId++; // read-modify-write — 원자적이지 않음!
}

// 수정: AtomicInteger 사용
private final AtomicInteger nextId = new AtomicInteger(0);
public int generateId() {
    return nextId.getAndIncrement(); // CAS 기반 원자적 연산
}

// 잘못된 코드 — 초기화 안 된 객체가 보일 수 있다
private Config config;
public void initialize() {
    config = new Config(); // 다른 스레드가 초기화 중인 config를 볼 수 있다
}

// 수정: volatile로 안전한 게시
private volatile Config config;
public void initialize() {
    Config c = new Config(); // 완전히 생성한 뒤
    config = c;              // volatile 쓰기로 안전하게 게시
}