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() 을 호출합니다.
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 를 몇으로 읽는지 보여 줍니다.
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 로 읽었다면 관계는 이렇게 이어집니다.
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++ 의 증가가 유실되지 않습니다.
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.