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

[manijang2]

---

CAS 연산1

1. 락 기반 방식의 문제

• synchronized, Lock 등을 사용하는 방식은 임계 영역에 진입하기 위해 락을 획득하고, 작업이 끝나면 락을 반납하는 흐름이 반복되는 구조이다.
• 락 기반 방식은 코드 흐름이 직관적이지만, 경쟁이 발생하면 락 획득 대기와 깨움 비용이 누적되면서 상대적으로 무거운 동기화 비용이 발생할 수 있다.
• 이런 단점 때문에, 락을 직접 잡지 않고도 공유 변수에 대한 원자적 변경을 시도하는 방식이 필요해지며, 그 핵심 원자 명령이 CAS(Compare-And-Swap) 연산이다.

2. 예제

package thread.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CasMainV1 {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        System.out.println("start value = " + atomicInteger.get());

        boolean result1 = atomicInteger.compareAndSet(0, 1);
        System.out.println("result1 = " + result1 + ", value = " + atomicInteger.get());

        boolean result2 = atomicInteger.compareAndSet(0, 1);
        System.out.println("result2 = " + result2 + ", value = " + atomicInteger.get());
    }
}

• new AtomicInteger(0) 코드는 내부 값을 0으로 초기화한다.
• 자바는 compareAndSet() 메서드를 통해 CAS 연산을 지원한다.
• 아래 출력은 compareAndSet(0, 1)이 첫 번째에는 성공하고, 두 번째에는 실패하는 상황을 보여준다.

start value = 0
result1 = true, value = 1
result2 = false, value = 1

• compareAndSet(0, 1) 메서드는 “현재 값이 0이면 1로 바꿔라”는 의미로 동작한다.
  • 현재 값이 0이라면 1로 변경되고 true를 반환한다.
  • 현재 값이 0이 아니라면 값은 변경되지 않고 false를 반환한다.
• compareAndSet(0, 1) 메서드는 원자적으로 실행되기 때문에 CAS 연산을 지원한다.

3. 실행 순서

• CAS 연산은 “메모리에 있는 값이 기대 값이면 원하는 값으로 변경한다”는 방식으로 이해할 수 있다.
• 즉, 아래 두 과정처럼 보이지만, 실제로는 중간 개입이 불가능한 한 덩어리의 원자 동작으로 취급된다.
  • 먼저, 메모리에 있는 값을 확인한다.
  • 해당 값이 기대하는 값이면 원하는 값으로 변경한다.

4. CPU 하드웨어 지원

• CAS 연산이 두 단계로 나뉘어 보이더라도, 실제 구현은 CPU가 제공하는 원자 명령을 기반으로 한다.
• CPU는 “비교”와 “교체”를 한 번에 처리하는 원자적 명령으로 제공하므로, 다른 스레드가 중간에 개입할 수 없다.

1) 성공시

• CPU는 CAS가 성공했음을 의미하는 true를 반환한다.

2) 실패시

• 실패 시 CPU는 false를 반환하고 값을 변경하지 않는다.

---

CAS 연산2

1. CAS 구현

package thread.cas;

import java.util.concurrent.atomic.AtomicInteger;

import static util.MyLogger.log;

public class CasMainV2 {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        System.out.println("start value = " + atomicInteger.get());

        int result1 = incrementAndGet(atomicInteger);
        System.out.println("result1 = " + result1 + ", value = " + atomicInteger.get());

        int result2 = incrementAndGet(atomicInteger);
        System.out.println("result2 = " + result2 + ", value = " + atomicInteger.get());
    }

    private static int incrementAndGet(AtomicInteger atomicInteger) {
        int getValue;
        boolean result;

        do {
            getValue = atomicInteger.get();
            log("getValue: " + getValue);
            result = atomicInteger.compareAndSet(getValue, getValue + 1);
            log("result: " + result);
        } while (!result);
        return getValue + 1;
    }
}

start value = 0
02:50:28 [     main] getValue: 0 
02:50:28 [     main] result: true 
result1 = 1, value = 1
02:50:28 [     main] getValue: 1 
02:50:28 [     main] result: true 
result2 = 2, value = 2

• incrementAndGet() 메서드는 먼저 atomicInteger.get()으로 현재 값을 읽어오고, 그 값을 기준으로 compareAndSet(getValue, getValue + 1)을 호출해 현재 값이 예상값(getValue)과 같을 때만 새 값(getValue + 1)으로 갱신을 시도한다.
• main 스레드 하나만 실행하는 구조이므로 경쟁이 발생하지 않으며, 그 결과 CAS 연산(compareAndSet)이 사실상 항상 성공한다.

---

CAS 연산3

1. 코드

package thread.cas;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import static util.MyLogger.log;
import static util.ThreadUtils.sleep;

public class CasMainV3 {

    private static final int THREAD_COUNT = 2;

    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger(0);
        System.out.println("start value = " + atomicInteger.get());

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                incrementAndGet(atomicInteger);
            }
        };

        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 = atomicInteger.get();
        System.out.println(atomicInteger.getClass().getSimpleName() + " resultValue = " + result);
    }

    private static int incrementAndGet(AtomicInteger atomicInteger) {
        int getValue;
        boolean result;

        do {
            getValue = atomicInteger.get();
            sleep(100);
            log("getValue: " + getValue);
            result = atomicInteger.compareAndSet(getValue, getValue + 1);
            log("result: " + result);
        } while (!result);
        return getValue + 1;
    }
}

• 2개의 스레드가 AtomicInteger의 값을 서로 증가시킨다.

start value = 0
01:53:28 [ Thread-1] getValue: 0
01:53:28 [ Thread-0] getValue: 0
01:53:28 [ Thread-1] result: true
01:53:28 [ Thread-0] result: false
01:53:28 [ Thread-0] getValue: 1
01:53:28 [ Thread-0] result: true
AtomicInteger resultValue = 2

• Thread-0, Thread-1이 거의 동시에 AtomicInteger의 값을 읽어 getValue: 0을 출력한다.
• 이후 Thread-1이 compareAndSet(0, 1)을 먼저 성공시키면서 실제 값이 1로 바뀐다.
• 이 시점에서 Thread-0은 여전히 “예상 값이 0일 것”이라고 가정하고 compareAndSet(0, 1)을 호출하므로, 이미 값이 1로 바뀐 상태여서 CAS가 실패(false)한다.
• Thread-0은 루프를 한 번 더 돌며 최신 값 1을 다시 읽고 compareAndSet(1, 2)를 수행해서 성공한다.
• 최종적으로 두 번의 증가가 반영되어 resultValue = 2가 된다.

2. 원리

• AtomicInteger에서 제공하는 incrementAndGet() 메서드는 내부적으로 CAS 루프를 사용하며, 지금 작성한 incrementAndGet()과 같은 형태로 동작한다고 이해할 수 있다.
• CAS 기반 증가 로직은 다음 흐름으로 이해하면 자연스럽다.
  1. 현재 값을 먼저 읽는다.
  2. 읽은 값(expected)이 여전히 현재 값과 동일한지 compareAndSet(expected, update)로 확인한다.
  3. 동일하다면 값을 갱신하고 종료한다.
  4. 동일하지 않다면 다른 스레드가 값을 바꾼 것이므로 실패하고, 다시 처음으로 돌아가 최신 값을 읽고 재시도한다.
• CAS 연산은 락처럼 “획득하고 기다리는 과정”이 없으므로, 락 경쟁으로 인한 블로킹 대기 시간과 컨텍스트 스위칭 오버헤드가 줄어드는 장점이 있다.
• 반대로 충돌이 자주 발생하면 실패와 재시도가 반복되어 CPU 자원을 많이 소모하는 스핀(spin) 상황이 발생할 수 있다.
• 특히 이 코드처럼 sleep(100)을 넣으면 경쟁 창이 커지면서 충돌 가능성이 커지고, 그 결과 CAS 실패 로그를 더 쉽게 관찰할 수 있다.

3. 비교

1) 락 방식

• 락 방식은 비관적(pessimistic) 접근이며, 다른 스레드가 항상 방해할 수 있다고 가정하는 방향으로 이해할 수 있다.
• 데이터에 접근하기 전에 항상 락을 획득하고, 락을 획득한 스레드만 임계 구역을 실행한다.
• 다른 스레드의 접근을 막기 때문에 충돌 자체를 구조적으로 제거하는 방식이다.
• 충돌이 많은 경우에는 “재시도 비용”이 아니라 “대기 비용”이 주요 비용이 되므로, 상황에 따라 락 방식이 더 유리해질 수 있다.

2) CAS 방식

• CAS 방식은 낙관적(optimistic) 접근이며, 대부분의 경우 충돌이 없을 것이라고 가정하고 먼저 실행하는 방식으로 이해할 수 있다.
• 락을 잡지 않고 데이터에 바로 접근한 뒤, compareAndSet()으로 값이 바뀌지 않았는지만 확인한다.
• 충돌이 발생하면 실패하고, 최신 값을 다시 읽어서 재시도한다.
• 충돌이 적은 경우에는 재시도 횟수가 적어 효율적이며, 블로킹이 없어서 전체 처리량이 좋아질 수 있다.
• 대부분의 연산이 짧게 끝나 경쟁 구간이 좁으면 충돌 확률이 낮아져 CAS가 유리해진다.