📌 volatile과 CAS(Compare-And-Swap): 데이터 정합성을 보장하는 방법

📌 CAS(Compare-And-Swap)와 volatile: 데이터 정합성을 보장하는 방법

synchronized 같은 락 기반 접근 방식도 있지만, 성능을 고려하면 비차단 동기화(Non-blocking Synchronization) 기법이 더욱 적합할 때가 있습니다.

저번 블로깅에서 동시성을 제어하는 방법에 대해서 알아보았는데 Java를 이용한 동시성 제어 방식에 CAS 연산이 짧게 나왔어서 CAS 연산과 추가로 volatile을 이용한 방식에 대해서 포스팅 해보려고 합니다.

이 글에서는 CAS(Compare-And-Swap)와 volatile을 활용하여 데이터 정합성을 보장하는 방법을 다루고, 테스트를 통해 검증해보도록 하겠습니다.

전체 코드는 깃헙레포에서 확인해주세요

---

1️⃣ volatile이란?

1.1 volatile의 정의

volatile은 JVM이 변수의 값을 직접 메인 메모리(Main Memory)에서 읽고 쓰도록 보장하는 키워드이다.
즉, 캐시를 사용하지 않고 모든 스레드가 항상 최신 값을 볼 수 있도록 가시성(visibility)을 제공한다.

private volatile int count = 0;

1.2 volatile의 특징

✅ 가시성(Visibility) 보장: 모든 스레드가 동일한 값을 보장받음
❌ 원자성(Atomicity) 미보장: count++ 같은 연산은 여전히 안전하지 않음
❌ 동기화(Synchronization) 미보장: 여러 스레드가 동시에 값을 변경하면 정합성이 깨질 수 있음

---

2️⃣ CAS(Compare-And-Swap)란?

2.1 CAS의 정의

CAS는 원자적으로 값을 변경할 수 있는 연산이다.
다음과 같은 과정으로 동작한다.

1. 현재 값(Old Value)을 읽어온다.
2. 예상 값(Old Value)이 여전히 메모리에 있는지 확인한다.
3. 맞으면 새로운 값(New Value)으로 변경한다.
4. 만약 변경 중 다른 스레드가 값을 바꿨다면, 변경에 실패하고 다시 시도한다.

2.2 CAS의 특징

✅ 원자성(Atomicity) 보장: CAS 연산 자체가 원자적이므로 락 없이 동시성을 처리할 수 있음
❌ 가시성(Visibility) 미보장: 여러 스레드가 동시에 CAS를 수행하면 최신 값을 보장하지 못할 수 있음
❌ ABA 문제 발생 가능: 예상 값이 바뀌었다가 다시 돌아온 경우에도 CAS가 성공할 수 있음

---

3️⃣ Unsafe를 사용하여 CAS 구현하기

CAS 연산을 수행하려면 JVM 내부에서 제공하는 Unsafe 클래스를 사용해야 한다.
하지만 Unsafe.getUnsafe()를 직접 호출하면 SecurityException이 발생하기 때문에,
리플렉션을 사용하여 Unsafe 객체를 가져오는 UnsafeUtil을 구현해야 한다.

3.1 UnsafeUtil: 리플렉션을 이용한 Unsafe 객체 접근

import sun.misc.Unsafe;
import java.lang.reflect.Field;

public class UnsafeUtil {
    private UnsafeUtil() {
        // 유틸리티 클래스는 객체 생성 방지
    }

    public static Unsafe getUnsafe() {
        try {
            // Unsafe 클래스의 theUnsafe 필드를 가져옴 (이 필드는 private static final 변수)
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true); // 접근 권한 해제
            return (Unsafe) field.get(null); // 필드 값을 가져와 Unsafe 객체로 캐스팅
        } catch (Exception e) {
            throw new RuntimeException("Unsafe instance cannot be obtained", e);
        }
    }
}

✅ 이제 UnsafeUtil.getUnsafe()를 호출하면 어디서든 Unsafe 객체를 안전하게 얻을 수 있다.

---

4️⃣ CAS vs volatile vs 일반 변수 비교 실험

이번 실험에서는 Product 클래스를 만들고,

• 일반 변수 (count)
• volatile 변수 (volatileCount)
• CAS만 적용한 변수 (countCAS())
• CAS + volatile 적용한 변수 (volatileCountCAS())
  이 네 가지 방식의 동작을 비교한다.

---

5️⃣ Product 클래스: 실험 코드

public class VolatileProduct {
    private int count = 0;
    private volatile int volatileCount = 0;

    private static final Unsafe unsafe = UnsafeUtil.getUnsafe();
    private final long countOffset;
    private final long volatileCountOffset;

    public VolatileProduct() throws NoSuchFieldException {
        this.countOffset = unsafe.objectFieldOffset(VolatileProduct.class.getDeclaredField("count"));
        this.volatileCountOffset = unsafe.objectFieldOffset(VolatileProduct.class.getDeclaredField("volatileCount"));
    }

    public void incrementCount() {
        count++;
    }

    public void incrementVolatileCount() {
        volatileCount++;
    }

    public void incrementCountCAS() {
        int oldValue;
        do {
            oldValue = unsafe.getInt(this, countOffset);
        } while (!unsafe.compareAndSwapInt(this, countOffset, oldValue, oldValue + 1));
    }

    public void incrementVolatileCountCAS() {
        int oldValue;
        do {
            oldValue = unsafe.getIntVolatile(this, volatileCountOffset);
        } while (!unsafe.compareAndSwapInt(this, volatileCountOffset, oldValue, oldValue + 1));
    }

    public int getCount() {
        return count;
    }

    public int getVolatileCount() {
        return volatileCount;
    }
}

---

6️⃣ 테스트 코드: CAS, volatile 비교

@Nested
    @DisplayName("incrementCount 메서드는")
    class IncrementCountMethod {
        @Test
        @DisplayName("일반 변수를 증가 시키는데 10개의 스레드로 1000번 실행해도 10000이 되지 않는다")
        void should_not_ensure_consistency_with_plain_variable()
            throws InterruptedException, NoSuchFieldException {
            // Given
            VolatileProduct volatileProduct = new VolatileProduct();
            ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);

            // When
            for (int i = 0; i < THREAD_COUNT; i++) {
                VolatileProduct finalVolatileProduct = volatileProduct;
                executor.submit(() -> {
                    for (int j = 0; j < INCREMENT_PER_THREAD; j++) {
                        finalVolatileProduct.incrementCount();
                    }
                });
            }
            executor.shutdown();
            executor.awaitTermination(5, TimeUnit.SECONDS);

            // Then
            assertNotEquals(EXPECTED_COUNT, volatileProduct.getCount());
        }
    }

---

7️⃣ 결과 분석

테스트 대상	결과	동시성 보장 여부	설명
incrementCount()	❌ 실패	❌	일반 변수는 동기화 문제 발생
incrementVolatileCount()	❌ 실패	❌	volatile은 가시성만 보장, 원자성 깨짐
incrementCountCAS()	⚠️ 부분 성공	⚠️ 부분 보장	CAS만으로 원자성을 유지하지만 최신 값 보장 X
incrementVolatileCountCAS()	✅ 성공	✅	CAS + volatile로 가시성과 원자성 모두 해결

---

8️⃣ 결론

• CAS만 사용하면 최신 값을 읽어오지 못할 가능성이 있음.
• CAS + volatile을 함께 사용하면 동시성 문제를 해결하면서 최신 값을 유지할 수 있음.
• 따라서 AtomicInteger 등 CAS 기반 클래스는 내부적으로 volatile을 사용함. 🚀

후기

테스트 코드가 상당히 불안정 합니다. 캐싱의 영향인지 CAS연산을 동반하는 메소드는 안정적으로 통과하지만 CAS연산이 없는 테스트는 각각 따로 진행하면 통과하지만 전체적으로 돌리면 매번 테스트 결과가 달라져 실패한 테스트 코드라고 할 수 있겠습니다. 더 방법을 찾아보겠습니다.