OSTEP 26장 Concurrency: An Introduction의 26.3절에는 두 스레드가 공유 변수 counter 를 각각 천만 번씩 1 늘리는 예제가 있습니다. 기대한 2천만이 나올 때도 있지만, 그보다 작은 값이 나올 때가 있고 그 값도 실행할 때마다 다릅니다. counter++ 가 CPU 에서는 세 단계로 실행될 수 있기 때문입니다.

LOAD  counter
ADD   1
STORE counter

한 스레드가 값을 읽고 저장하기 전에 다른 스레드가 같은 값을 읽으면, 두 번 더한 결과가 한 번만 남습니다. 이 세 단계를 나뉘지 않는 하나의 단위로 실행하는 성질이 원자성(atomicity)이고, OSTEP 은 이어지는 장에서 lock 과 하드웨어 원자 명령으로 이 문제를 해결합니다.

27장 Interlude: Thread API는 두 스레드 사이에 신호를 보낼 때 lock 없이 flag 변수 하나만 쓰지 말라고 경고합니다. flag 를 쓰고 읽는 일에는 counter++ 처럼 나뉠 단계가 없는데 무엇이 잘못될 수 있는지 궁금해졌습니다.

한 스레드가 바꾼 값은 다른 스레드에 바로 보일까요? CPU 와 컴파일러는 코드에 적힌 순서를 그대로 지킬까요? 원자적 연산만 쓰면 이런 문제도 함께 해결될까요?

OSTEP 26, 27장과 Java Language Specification(JLS) 17장, JDK 21 의 AtomicInteger 문서, JSR-133 Cookbook 을 읽고 정리했습니다. 예제 코드를 직접 실행하거나 측정한 결과는 없고, Java 의 동작은 Java SE 21 의 JLS 를 기준으로 합니다.

1. 종료 flag 는 왜 반복문을 멈추지 못할 수 있을까요?

27장의 flag 를 Java 로 옮기면 이런 코드가 됩니다.

class Worker {

    private boolean running = true;

    public void run() {
        while (running) {
            // 작업 수행
        }
    }

    public void stop() {
        running = false;
    }
}

Thread A 가 run() 을 실행하는 동안 Thread B 가 stop() 을 호출합니다.

Thread B 가 running 에 false 를 쓴 뒤에도 Thread A 의 읽기가 false 를 얻는다는 보장이 없습니다.

B 가 running 을 false 로 바꿨으니 A 의 반복문도 끝날 것 같습니다. 하지만 Java 는 A 가 언젠가 false 를 읽는다고 보장하지 않습니다. 한 스레드가 쓴 값을 다른 스레드가 읽을 수 있는지에 관한 문제를 가시성(visibility) 문제라고 합니다.

코어마다 캐시가 따로 있으니 A 의 코어가 예전 값을 계속 들고 있는 걸까요? 이 경우는 하드웨어가 막습니다. 한 코어가 어떤 변수에 쓰려면 먼저 다른 코어의 캐시에 있는 그 변수의 사본을 무효로 만들고, 그 뒤 다른 코어가 그 변수를 읽으면 새 값을 받아 옵니다. 이 규칙을 cache coherence 라고 합니다.

반복문이 끝나지 않는다면 원인은 컴파일러 쪽에 있을 가능성이 큽니다. 컴파일러와 CPU 는 한 스레드만 놓고 봤을 때 결과가 같다면 코드를 바꿔서 실행해도 됩니다. run() 의 반복문 안에는 running 을 바꾸는 코드가 없으므로, JIT 컴파일러는 run() 을 이렇게 바꿀 수 있습니다.

// JIT 컴파일러가 바꿀 수 있는 모습
boolean r = running;   // running 을 한 번만 읽습니다
while (r) {
    // 작업 수행
}

바뀐 코드는 running 을 다시 읽지 않으므로 B 가 false 를 써도 반복문이 끝나지 않습니다. JLS 17.3 에도 필드를 한 번만 읽어서 반복문이 끝나지 않는 예제가 있습니다. 참고: JLS 17.3.

running 을 volatile 로 선언하면 이 문제가 사라집니다.

private volatile boolean running = true;

JIT 컴파일러는 volatile 변수의 읽기를 한 번으로 줄이거나 반복문 밖으로 옮길 수 없습니다. 그리고 Java 는 volatile 변수에 쓴 값이 그 뒤에 같은 변수를 읽는 스레드에 보인다고 보장합니다. 그래서 Thread A 는 매번 running 을 다시 읽고, B 가 쓴 false 를 읽으면 반복문을 끝냅니다.

Java 에서 boolean 변수 하나를 쓰는 일은 중간에 나뉘지 않으므로 running = false 는 counter++ 와 달리 원자적인 쓰기입니다. 그런데도 Thread A 가 이 값을 읽는다는 보장은 없었습니다.

2. 코드에 적힌 순서는 그대로 지켜질까요?

Thread A 는 데이터를 준비하고 ready 를 켭니다. Thread B 는 ready 가 켜졌으면 data 를 출력합니다. 두 변수의 초깃값은 0 과 false 입니다.

// Thread A
data = 100;
ready = true;

// Thread B
if (ready) {
    System.out.println(data);
}

B 가 ready 를 true 로 읽었다면 data 도 100 일 것이라고 기대하게 됩니다. 하지만 두 쓰기의 순서가 바뀌어도 Thread A 혼자서는 결과가 같으므로, 1절의 run() 처럼 컴파일러가 코드를 바꿀 수 있습니다.

// 컴파일러가 바꿀 수 있는 모습
ready = true;
data = 100;

컴파일러가 이렇게 바꾸면 B 는 ready == true 를 읽고도 data 를 0으로 읽을 수 있습니다. B 쪽에서도 data 를 ready 보다 먼저 읽는 일이 생길 수 있습니다. 여러 메모리 연산이 다른 스레드에 어떤 순서로 보이는지에 관한 문제를 순서(ordering) 문제라고 합니다.

CPU 도 순서를 바꿀 수 있습니다. 코어는 쓴 값을 바로 캐시에 넣지 않고 store buffer 라는 대기열에 잠시 넣어 둡니다. 다른 코어도 같은 변수를 캐시에 갖고 있으면 그 사본을 무효로 만든 뒤에야 캐시에 쓸 수 있어서, 그동안 쓰기는 store buffer 에서 기다립니다. ARM 같은 CPU 는 기다리는 쓰기를 두고 뒤의 쓰기를 먼저 캐시에 반영할 수 있습니다. 다음 데모에서 data 쓰기가 기다리는 동안 Thread B 가 무엇을 읽는지 확인할 수 있습니다.

ready 가 true 면 data 는 100 일까요?

Thread A 는 data 를 먼저, ready 를 나중에 씁니다. ready 에 volatile 을 붙일지 고르면, 두 쓰기가 store buffer 에서 어떤 순서로 캐시에 반영되고 Thread B 가 data 를 몇으로 읽는지 보여 줍니다.

Thread A 가 쓴 순서 data, ready 캐시에 반영된 순서 없음 Thread B 가 출력한 값 없음

store buffer 와 캐시를 단순화한 모형입니다. 캐시 사본의 상태 규칙, 무효화 응답(ack), invalidate queue, out-of-order execution 은 그리지 않았고, Thread B 가 ready 를 읽는 시점은 ready 가 캐시에 반영된 직후로 정했습니다. "volatile 없음"은 ARM 처럼 쓰기 순서를 바꿀 수 있는 CPU 를 가정했고, 순서가 바뀌는 실제 경로는 CPU 구현마다 다릅니다. 컴파일러가 순서를 바꾸는 경우와 Thread B 의 두 읽기 순서가 바뀌는 경우는 그리지 않았습니다. volatile 은 이 두 경우도 막습니다. 움직이는 시간은 실제 지연과 관계없습니다.

x86 은 store buffer 의 쓰기를 들어온 순서대로 캐시에 반영하므로 이 예제의 두 쓰기 순서를 바꾸지 않습니다. 하지만 컴파일러는 x86 에서도 순서를 바꿀 수 있어서, Java 코드에서는 CPU 와 관계없이 이 순서가 보장되지 않습니다. 참고: The JSR-133 Cookbook for Compiler Writers.

3. volatile 은 순서를 어떻게 지킬까요?

데모의 “ready 를 volatile 로” 모드처럼 ready 만 volatile 로 바꿉니다.

class Example {

    private int data = 0;
    private volatile boolean ready = false;

    public void produce() {
        data = 100;
        ready = true;
    }

    public void consume() {
        if (ready) {
            System.out.println(data);
        }
    }
}

JVM 은 volatile 쓰기 앞의 쓰기를 그 뒤로 옮기지 않고, volatile 읽기 뒤의 읽기를 그 앞으로 옮기지 않습니다. 컴파일러는 이 순서를 바꾸지 않고, CPU 가 순서를 바꿀 수 있으면 JVM 이 순서를 강제하는 명령(memory barrier)을 함께 넣습니다.

그런데 data 는 volatile 이 아닙니다. Java 는 앞의 작업과 뒤의 작업이 다음 표의 관계일 때 앞의 작업 결과가 뒤의 작업에 보인다고 보장합니다(JLS 17.4.5).

앞의 작업뒤의 작업
같은 스레드에서 코드상 앞에 있는 작업같은 스레드에서 코드상 뒤에 있는 작업
volatile 변수에 쓰기그 뒤에 같은 변수를 읽는 다른 스레드의 읽기
lock 해제그 뒤에 다른 스레드가 같은 lock 을 획득

Java 는 이 관계를 happens-before 라고 부르고, 관계를 이어 붙일 수 있습니다. 작업 X 가 Y 보다, Y 가 Z 보다 happens-before 이면 X 도 Z 보다 happens-before 입니다.

Thread A 가 produce() 를, Thread B 가 consume() 을 실행하고 B 가 ready 를 true 로 읽었다면 관계는 이렇게 이어집니다.

B 가 ready 를 true 로 읽은 경우입니다. 세 관계를 이어 붙인 happens-before 에 따라 B 의 data 읽기는 100 을 얻습니다.

A 안에서 data = 100 은 코드 순서로 ready = true 보다 앞에 있습니다. B 가 그 true 를 읽었으니 volatile 쓰기 뒤의 읽기이고, B 안에서 ready 읽기는 코드 순서로 data 읽기보다 앞에 있습니다. 세 관계를 이어 붙이면 A 의 data = 100 이 B 의 data 읽기보다 happens-before 이므로 B 는 100을 읽습니다. 그래서 data 에는 volatile 이 없어도 됩니다.

이 보장은 B 가 ready 를 true 로 읽었을 때만 생깁니다. 코드에서 ready = true 를 data = 100 보다 위에 쓰면 B 가 true 를 읽고도 data 를 0으로 읽을 수 있습니다.

happens-before 는 이름과 달리 시간상 먼저 실행됐다는 뜻이 아닙니다. 1절에서 volatile 이 없을 때 running = false 는 시간상 A 의 다음 읽기보다 먼저 실행됐지만, 두 작업 사이에 이 관계가 없어서 A 는 false 를 읽지 못할 수 있었습니다.

4. volatile 이면 counter++ 도 안전할까요?

volatile int counter 에 두 스레드가 counter++ 를 해도 증가가 유실됩니다. volatile 은 읽기와 쓰기 각각을 다른 스레드에 보이게 할 뿐, 읽고 더하고 쓰는 세 단계를 하나의 연산으로 만들지 않습니다. 두 스레드가 같은 값을 읽고 각자 1을 더해 쓰면 여전히 한 번만 늘어납니다. 원자성이 필요하면 synchronized 나 AtomicInteger 를 씁니다.

synchronized 는 무엇을 보장할까요?

class Counter {

    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

synchronized 메서드는 실행을 시작할 때 그 객체의 lock(모니터)을 획득하고, 끝날 때 해제합니다. 같은 lock 을 쓰는 메서드는 한 번에 한 스레드만 실행하므로 count++ 의 증가가 유실되지 않습니다.

B 는 A 가 같은 lock 을 해제하기 전에 수정한 데이터를 읽을 수 있습니다.

3절 표의 lock 규칙에 따라, 한 스레드가 lock 을 해제하기 전에 바꾼 count 는 다음에 같은 lock 을 획득한 스레드에 보입니다.

getCount() 에도 synchronized 를 붙였습니다. 읽기만 하니 lock 이 필요 없어 보이지만, lock 없이 읽으면 increment() 의 lock 해제와 happens-before 관계가 생기지 않아 increment() 가 쓴 값을 읽지 못할 수 있습니다.

AtomicInteger 는 무엇을 보장할까요?

AtomicInteger counter = new AtomicInteger(0);

counter.incrementAndGet();

AtomicInteger 는 하드웨어의 원자 명령으로 읽기, 더하기, 쓰기를 한 번에 실행합니다. 여러 스레드가 동시에 incrementAndGet() 을 불러도 증가가 유실되지 않습니다. JDK 21 문서에 따르면 get() 은 volatile 읽기와, set() 은 volatile 쓰기와 같은 메모리 효과를 갖고, incrementAndGet() 은 둘 다 갖습니다. 그래서 AtomicInteger 에 쓴 값도 3절 표의 volatile 규칙에 따라 다른 스레드에 보입니다. 참고: AtomicInteger (JDK 21).

5. 처음 질문으로 돌아가면

한 스레드가 바꾼 값은 다른 스레드에 바로 보일까요? CPU 와 컴파일러는 코드에 적힌 순서를 그대로 지킬까요? 원자적 연산만 쓰면 이런 문제도 함께 해결될까요?

문제어긋나는 원인Java 에서 보장하는 방법
원자성counter++ 가 읽기, 더하기, 쓰기 세 단계로 나뉩니다synchronized, AtomicInteger
가시성JIT 컴파일러가 반복되는 읽기를 한 번으로 줄입니다volatile, synchronized, AtomicInteger
순서컴파일러와 CPU 가 서로 관계없는 쓰기나 읽기의 순서를 바꿉니다volatile 쓰기와 읽기, 같은 lock 의 해제와 획득, AtomicInteger

컴파일러와 CPU 는 한 스레드의 결과만 같으면 읽기를 줄이고 순서를 바꿀 수 있습니다. 그래서 volatile 이나 lock 이 없으면 한 스레드가 바꾼 값이 다른 스레드에 언제, 어떤 순서로 보일지 정해지지 않습니다. running = false 처럼 이미 원자적인 쓰기도 마찬가지입니다. Java 에서 공유 변수를 다룰 때는 쓰는 쪽과 읽는 쪽이 같은 volatile 변수나 같은 lock 으로 이어져 happens-before 관계가 생기는지를 따져야 합니다.


학습 자료: Remzi H. Arpaci-Dusseau, Andrea C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces, Chapter 26 Concurrency: An Introduction, Chapter 27 Interlude: Thread API. Oracle, The Java Language Specification, Java SE 21 Edition, Chapter 17 Threads and Locks. Oracle, AtomicInteger (JDK 21). Doug Lea, The JSR-133 Cookbook for Compiler Writers.