섹션 10. CAS - 동기화와 원자적 연산 (1)

[manijang2]

원자적 연산 - 소개

1. 원자적 연산

• 원자적 연산은 연산이 더 이상 쪼갤 수 없는 하나의 단위로 수행되는 연산을 의미한다.
• 원자적 연산은 실행 도중에 끼어들 수 없기 때문에, 멀티스레드 환경에서도 완전히 실행되거나 전혀 실행되지 않는 성질을 가진다.
• 멀티스레드 상황에서 원자적 연산은 다른 스레드의 간섭 없이 안전하게 처리되는 연산을 뜻한다.
• 원자적 연산이 아닌 경우에는 synchronized 또는 Lock으로 임계 영역을 명확하게 보호해서 동시성 문제를 막아야 한다.

volatile int i = 0;
i = 1;

• 위 코드는 i = 1;처럼 단일 쓰기(write) 로 끝나는 형태이므로, 해당 쓰기 자체는 원자적으로 수행되는 연산으로 이해할 수 있다.
• 다만 멀티스레드에서 의미 있는 “안전함”을 확보하려면, 원자성뿐 아니라 가시성(다른 스레드가 최신 값을 보는가) 과 연산 전체의 일관성(검증+변경이 하나로 묶이는가) 을 함께 고려해야 한다.

volatile int i = 0;
i = i + 1; // or i++;

• i = i + 1;은 원자적 연산이 아니다.
• i++도 내부적으로는 i = i + 1`과 같은 읽기(read) → 계산(add) → 쓰기(write) 단계로 분해되므로 원자적 연산이 아니다.
• 이 형태는 “단일 연산처럼 보이지만 실제로는 여러 단계로 쪼개지는 복합 연산”이기 때문에, 두 스레드가 동시에 실행하면 값이 덮어써지며 누락(lost update) 이 발생할 수 있다.
• 이 과정에서 각 단계 사이에 다른 스레드가 끼어들 수 있으므로, 결과적으로 증가가 누락되는 상황이 생긴다.

---

원자적 연산 - 시작

1. 코드

package thread.cas.increment;  
  
public interface IncrementInteger {  
    void increment();  
    int get();  
}

• 하나의 값을 증가시키는 인터페이스를 만든다.

package thread.cas.increment;  
  
public class BasicInteger implements IncrementInteger {  
  
    private int value;  
  
    @Override  
    public void increment() {  
        value++;  
    }  
  
    @Override  
    public int get() {  
        return value;  
    }  
}

• increment()메서드를 통하여 값을 하나 증가시킨다.
• value++연산은 여러 스레드에서 공유될 수 있으며, ++연산과 같이 원자적이지 않은 연산을 사용하면 문제가 발생할 수 있다.

package thread.cas.increment;  
  
import java.util.ArrayList;  
import java.util.List;  
  
import static util.ThreadUtils.sleep;  
  
public class IncrementThreadMain {  
    public static final int THREAD_COUNT = 1000;  
  
    public static void main(String[] args) throws InterruptedException {  
        test(new BasicInteger());  
    }  
  
    private static void test(IncrementInteger incrementInteger) throws InterruptedException {  
        Runnable runnable = () -> {  
            sleep(10);  
            incrementInteger.increment();  
        };  
  
        List<Thread> threads = new ArrayList<>();  
        for (int i = 0; i < THREAD_COUNT; i++) {  
            Thread thread = new Thread(runnable);  
            threads.add(thread);  
            thread.start();  
        }  
  
        for (Thread thread : threads) {  
            thread.join();  
        }  
  
        int result = incrementInteger.get();  
        System.out.println(incrementInteger.getClass().getSimpleName() + " result : " + result);  
    }  
}

• THREAD_COUNT만큼 스레드를 생성하고 incrementInteger.increment()을 호출한다.
• sleep(10)은 모든 스레드를 비슷한 타이밍에 실행시키는 효과가 있어 경쟁 상태를 더 잘 재현하게 만든다.

BasicInteger result : 963

• 기대 결과는 스레드가 1000개이고 각 스레드가 1번씩 증가시키므로 1000이어야 한다.
• 하지만 실제 결과가 963처럼 더 작게 나오는 이유는, value++가 원자적이지 않아 두 스레드가 같은 값을 읽고 각각 +1을 계산한 뒤, 마지막에 쓴 값이 이전 쓰기를 덮어써서 증가 1회가 사라지는 상황이 반복되기 때문이다.

---

원자적 연산 - volatile, synchronized

1. volatile

package thread.cas.increment;  
  
public class VolatileInteger implements IncrementInteger {  
  
    private volatile int value;  
  
    @Override  
    public void increment() {  
        value++;  
    }  
  
    @Override  
    public int get() {  
        return value;  
    }  
}

• value 변수에 volatile를 추가한 구현이다.
• volatile은 한 스레드가 변경한 값을 다른 스레드가 더 잘 관찰할 수 있도록 가시성(visibility) 과 happens-before를 강화하는 역할을 한다.
• 하지만 value++는 내부적으로 읽기(read) → 계산(add) → 쓰기(write) 로 분해되는 복합 연산이므로, volatile을 붙여도 연산 전체가 원자적으로 묶이지 않는다.
• 따라서 여러 스레드가 동시에 증가시키면, 서로 같은 값을 읽은 뒤 같은 결과를 써서 증가가 누락되는 경쟁 상태가 그대로 발생한다.

VolatileInteger result : 989

• 기대값이 1000인데 989처럼 작게 나오는 것은 volatile이 “값을 잘 보이게” 해 줄 뿐, “증가 연산 자체를 한 번에 끝내게” 만들지는 못하기 때문이다.
• “CPU 캐시를 무시하고 메인 메모리를 직접 참조한다”는 표현은 학습 관점에서 도움이 되지만, 실제로는 JVM/JMM 관점에서 volatile은 메모리 가시성과 재정렬 제한(메모리 배리어 효과) 을 제공한다고 이해하는 편이 더 안전하다.
• 결론적으로 이 문제는 가시성 문제가 아니라 원자성 문제이므로, synchronized 또는 Lock으로 임계 영역을 만들거나, AtomicInteger처럼 CAS 기반 원자 연산을 사용해야 한다.

2. synchronized

package thread.cas.increment;  
  
public class SyncInteger implements IncrementInteger {  
  
    private int value;  
  
    @Override  
    public synchronized void increment() {  
        value++;  
    }  
  
    @Override  
    public synchronized int get() {  
        return value;  
    }  
}

• synchronized를 통해 increment() 전체가 임계 영역이 되며, 동시에 하나의 스레드만 value++를 수행할 수 있게 만든다.
• 이렇게 하면 value++가 복합 연산이라도 한 번에 한 스레드만 접근하게 되므로 증가 누락이 발생하지 않는다.
• get()에도 synchronized를 붙이면, increment()와 같은 락을 공유하게 되어 조회 또한 일관된 흐름으로 보호된다.

SyncInteger result : 1000

• 기대값과 동일한 결과가 나오는 것은 임계 영역 보호를 통해 원자성이 확보되었기 때문이다.

---

원자적 연산 - AtomicInteger

1. 코드

• 자바는 SyncInteger처럼 synchronized로 임계 영역을 만들어 증가 연산을 안전하게 처리할 수도 있고, 별도로 AtomicInteger를 제공하여 락을 명시적으로 사용하지 않고도 원자적 증가 연산을 수행할 수 있게 한다.
• AtomicInteger는 멀티스레드 환경에서 증가 연산이 누락되지 않도록 내부적으로 원자적 연산을 제공하며, 단순 카운터와 같은 패턴에서 자주 사용한다.

package thread.cas.increment;  
  
import java.util.concurrent.atomic.AtomicInteger;  
  
public class MyAtomicInteger implements IncrementInteger {  
  
    AtomicInteger atomicInteger = new AtomicInteger(0);  
  
    @Override  
    public void increment() {  
        atomicInteger.incrementAndGet();  
    }  
  
    @Override  
    public int get() {  
        return atomicInteger.get();  
    }  
}

• AtomicInteger 객체를 선언하고 0으로 초기화한다.
• incrementAndGet()은 내부적으로 증가 연산을 원자적으로 처리하여, 여러 스레드가 동시에 호출해도 증가 누락이 발생하지 않는다.
• get()은 현재 값을 안전하게 읽을 수 있도록 제공되는 조회 메서드이다.

MyAtomicInteger result : 1000

• 정상적인 결과가 나오는 것을 확인할 수 있다.

---

원자적 연산 - 성능 테스트

1. 코드

package thread.cas.increment;  
  
public class IncrementPerformanceMain {  
  
    public static final long COUNT = 100_000_000;  
  
    public static void main(String[] args) throws InterruptedException {  
        test(new BasicInteger());  
        test(new VolatileInteger());  
        test(new SyncInteger());  
        test(new MyAtomicInteger());  
    }  
  
    private static void test(IncrementInteger incrementInteger) {  
        long startMs = System.currentTimeMillis();  
        for (int i = 0; i < COUNT; i++) {  
            incrementInteger.increment();  
        }  
        long endMs = System.currentTimeMillis();  
        System.out.println(incrementInteger.getClass().getSimpleName() + " ms = " + (endMs - startMs));  
    }  
  
}

1) BasicInteger

• CPU 캐시를 사용하기 때문에 가장 빠르다.
• 임계 영역도 없고, volatile도 사용하지 않아 멀티스레드 상황에서는 사용할 수 없다.
• 단일 스레드를 사용하는 경우 효율적이다.
• value++는 단일 스레드에서는 직관적으로 기대한 대로 동작하지만, 멀티스레드에서는 원자성이 보장되지 않아 증가 누락이 발생할 수 있다.

2) VolatileInteger

• volatile를 사용하여 CPU 캐시를 사용하지 않고 메인 메모리를 사용한다.
• 임계 영역이 없기 때문에 멀티 스레드 상황에서는 사용할 수 없다.
• 단일 스레드를 사용하기에는 BasicInteger 보다 느리고, 멀티스레드 상황에서도 안전하지 않다.
• volatile은 가시성과 순서 보장에 관여하지만, value++ 같은 복합 연산을 원자적으로 만들지는 못하므로 증가 누락 문제는 그대로 발생할 수 있다.

3) SyncInteger

• synchronized를 사용한 임계 영역이 있기 때문에 멀티 스레드 상황에서도 안전하게 사용할 수 있다.
• 가장 느리다.
• synchronized는 한 번에 하나의 스레드만 임계 영역에 들어오게 만들어 원자성을 확보하므로, 멀티스레드에서도 결과가 안정적이다.

4) MyAtomicInteger

• 자바에서 제공해주는 AtomicInteger를 사용하며, 멀티스레드 상황에서도 안전하게 사용할 수 있다.
• 성능도 synchronized, Lock(ReentrantLock)를 사용할 때보다 더 빠르다.
• AtomicInteger.incrementAndGet()은 CAS 기반의 원자 연산을 활용해 증가를 안전하게 처리하는 방식으로 이해할 수 있다.