[JAVA] 동시성 제어를 위한 Atomic과 CAS

컴퓨터 과학에서 사용하는 원자적 연산(atomic operation)의 의미는 해당 연산이 더 이상 나눌 수 없는 단위로 수행된 다는 것을 의미합니다. 즉, 원자적 연산은 중단되지 않고, 다른 연산과 간섭 없이 완전히 실행되거나 전혀 실행되지 않는 성질을 가지고 있습니다. 쉽게 이야기해서 멀티스레드 상황에서 다른 스레드의 간섭 없이 안전하게 처리되는 연산이라는 뜻입니다.

예를 들어서 다음과 같은 필드가 있을 때

• int i = 0;

다음 연산은 둘로 쪼갤 수 없는 원자적 연산입니다.

• i = 1;

왜냐하면 이 연산은 다음 단 하나의 순서로 실행되기 때문입니다.(오른쪽에 있는 1 의 값은 왼쪽의 i 변수에 대입한다.)

하지만 다음 연산은 원자적 연산이 아닙니다.

• i = i + 1;

왜냐하면 이 연산은 다음 순서로 나누어 실행되기 때문입니다.

1. 오른쪽에 있는 i의 값을 읽는다. i의 값은 10이다.
2. 읽은 10에 1을 더해서 11을 만든다.
3. 더한 11을 왼쪽의 i 변수에 대입한다.

원자적 연산은 멀티스레드 상황에서 아무런 문제가 발생하지 않지만, 원자적 연산이 아닌 경우에는 synchronized 블럭이나 Lock 등을 사용해서 안전한 임계 영역을 만들어야 합니다.

순서대로 실행

예를 들어서 2개의 스레드가 해당 로직을 수행하는데, 하나가 완전히 끝나고 나서, 나머지 하나가 수행된다고 가정해보겠습니다.

처음에 i = 0 이라고 가정합니다.

스레드1: i = i + 1 연산 수행
스레드1: i의 값을 읽는다. i는 0이다.
스레드1: 읽은 0에 1을 더해서 1을 만든다.
스레드1: 더한 1을 왼쪽의 i변수에 대입한다.
결과: i의 값은 1이다.

스레드2: i = i + 1 연산 수행
스레드2: i의 값을 읽는다. i는 1이다. 
스레드2: 읽은 1에 1을 더해서 2을 만든다.
스레드2: 더한 2을 왼쪽의 i변수에 대입한다.
결과: i의 값은 2가 된다.

2개의 스레드가 각각 한 번 연산을 수행했으므로 변수 i의 값은 0 -> 2가 됩니다.

동시에 실행

이번에는 문제가 되는 경우를 알아보겠습니다. 2개의 스레드가 해당 로직을 동시에 함께 수행하면, 문제가 발생합니다.

처음에 i = 0이라고 가정하겠습니다.

스레드1: i = i + 1 연산 수행 
스레드2:i = i + 1 연산 수행
스레드1: i의 값을 읽는다. i는 0이다.
스레드2: i의 값을 읽는다. i는 0이다.
스레드1: 읽은 0에 1을 더해서 1을 만든다.
스레드2: 읽은 0에 1을 더해서 1을 만든다.
스레드1: 더한 1을 왼쪽의 i변수에 대입한다.
스레드2: 더한 1을 왼쪽의 i변수에 대입한다.
결과: i의 값은 1이다.

2개의 스레드가 각각 한 번 연산을 수행했지만, 변수 i의 값은 0 -> 1이 됩니다. 한 번의 연산이 사라진 것입니다.

원자적 연산

원자적이지 않은 연산을 멀티스레드 환경에서 실행하면 어떤 문제가 발생하는지 예제 코드로 알아보겠습니다. IncrementInteger는 숫자 값을 하나씩 증가시키는 기능을 제공합니다. 예를 들어서 지금까지 접속한 사용자의 수 등을 계산할 때 사용할 수 있습니다.

public interface IncrementInteger {

    void increment();

    int get();
}

• IncrementInteger는 값을 증가하는 기능을 가진 숫자 기능을 제공하는 인터페이스입니다.
• increment() : 값을 하나 증가시킵니다.
• get() : 값을 조회합니다.

public class BasicInteger implements IncrementInteger {

    private int value;

    @Override
    public void increment() {
        value++; 
    }

    @Override
    public int get() {
        return value;
    }
}

• increment() 를 호출하면 value++ 를 통해서 값을 하나 증가시킵니다.
  • value 값은 인스턴스의 필드이기 때문에, 여러 스레드가 공유할 수 있습니다. 이렇게 공유 가능한 자원에 ++와 같은 원자적이지 않은 연산을 사용하면 멀티스레드 상황에 문제가 될 수 있습니다.

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 = new Runnable() {
            @Override
            public void run() {
                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);
    }

    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

• THREAD_COUNT 수 만큼 스레드를 생성하고 incrementInteger.increment() 를 호출합니다.
• 스레드를 1,000개 생성했다면, increment() 메서드도 1,000번 호출하기 때문에 결과는 1,000이 되어야합니다.
• 참고로 스레드가 너무 빨리 실행되기 때문에, 여러 스레드가 동시에 실행되는 상황을 확인하기 어렵습니다. 그래서 run() 메서드에 sleep(10)을 두어서, 최대한 많은 스레드가 동시에 increment() 를 호출하도록 합니다.

실행 결과

BasicInteger result: 950

실행 결과를 보면 기대한 1,000이 아니라 다른 숫자가 보입니다. 아마도 실행 환경에 따라서 다르겠지만 1,000이 아니라 조금 더 적은 숫자가 보일 것입니다. 이 문제는 앞서 설명한 것처럼 여러 스레드가 동시에 원자적이지 않은 value++ 을 호출했기 때문에 발생하게 됩니다.

volatile

그럼 혹시 volatile 을 적용하면 이 문제가 해결될지 적용해보겠습니다.

public class VolatileInteger implements IncrementInteger {

      private volatile int value;

      @Override
      public void increment() {
          value++;
      }

      @Override
      public int get() {
          return value;
      }
}

• BasicInteger와 동일하지만, 필드에 volatile만 적용하였습니다.

public class IncrementThreadMain {

    public static final int THREAD_COUNT = 1000;

    public static void main(String[] args) throws InterruptedException {
        test(new BasicInteger());
        test(new VolatileInteger()); // 추가
    }

    private static void test(IncrementInteger incrementInteger) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                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);
    }

    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

실행 결과

BasicInteger result: 950
VolatileInteger result: 961

실행 결과를 보면 VolatileInteger 도 여전히 1,000이 아니라 더 작은 숫자가 나옵니다.

volatile은 여러 CPU 사이에 발생하는 캐시 메모리와 메인 메모리가 동기화 되지 않는 문제를 해결할 뿐입니다. volatile을 사용하면 CPU의 캐시 메모리를 무시하고, 메인 메모리를 직접 사용하도록 할 수 있습니다. 하지만 지금 이 문제는 캐시 메모리가 영향을 줄 수는 있지만, 캐시 메모리를 사용하지 않고, 메인 메모리를 직접 사용해도 여전히 발생하는 문제입니다.

이 문제는 연산 자체가 나누어져 있기 때문에 발생했고, volatile은 연산 자체를 원자적으로 묶어주는 기능이 아닙니다.
이렇게 연산 자체가 나누어진 경우에는 synchronized 블럭이나 Lock등을 사용해서 안전한 임계 영역을 만들어야 합니다.

synchronized

이번에는 SyncInteger클래스를 만들고 synchronized를 적용해서 안전한 임계 영역을 만들어보겠습니다.

public class SyncInteger implements IncrementInteger {

      private int value;

      @Override
      public synchronized void increment() {
          value++; 
      }

      @Override
      public synchronized int get() {
          return value;
      }
}

• value++ 연산은 synchronized를 통해 임계 영역 안에서 안전하게 수행됩니다. 즉, 한 번에 하나의 스레드만 해당 연산을 수행할 수 있습니다.

public class IncrementThreadMain {

    public static final int THREAD_COUNT = 1000;

    public static void main(String[] args) throws InterruptedException {
        test(new BasicInteger());
        test(new VolatileInteger());
        test(new SyncInteger()); //추가
    }

    private static void test(IncrementInteger incrementInteger) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                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);
    }

    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

실행 결과

BasicInteger result: 950
VolatileInteger result: 961
SyncInteger result: 1000

synchronized를 통해 안전한 임계 영역을 만들고 value++ 연산을 수행했더니 정확히 1000이라는 결과가 나온 것을 확인할 수 있습니다. 1,000개의 스레드가 안전하게 value++ 연산을 수행한 것입니다.

AtomicInteger

자바는 앞서 만든 SyncInteger 와 같이 멀티스레드 상황에서 안전하게 증가 연산을 수행할 수 있는 AtomicInteger라는 클래스를 제공합니다. 이번에는 MyAtomicInteger 클래스를 만들고, 자바가 제공하는 AtomicInteger 를 사용해보겠습니다.

public class MyAtomicInteger implements IncrementInteger {

    AtomicInteger atomicInteger = new AtomicInteger(0);

    @Override
    public void increment() {
        atomicInteger.incrementAndGet();
    }
    @Override
    public int get() {
        return atomicInteger.get();
    }
}

• incrementAndGet() : 값을 하나 증가하고 증가된 결과를 반환합니다.
• get() : 현재 값을 반환합니다.

public class IncrementThreadMain {

    public static final int THREAD_COUNT = 1000;

    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) throws InterruptedException {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                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);
    }

    private static void sleep(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

실행 결과

BasicInteger result: 950
VolatileInteger result: 961
SyncInteger result: 1000
MyAtomicInteger result: 1000

실행 결과를 보면 AtomicInteger를 사용하면 MyAtomicInteger의 결과도 1000인 것을 확인할 수 있습니다. 1,000개의 스레드가 안전하게 증가 연산을 수행한 것입니다.

AtomicInteger는 멀티스레드 상황에 안전하고 또 다양한 값 증가, 감소 연산을 제공합니다. 특정 값을 증가하거나 감소해야 하는데 여러 스레드가 해당 값을 공유해야 한다면, AtomicInteger를 사용하면 됩니다.

성능 비교

BasicInteger

• 가장 빠릅니다.
• CPU 캐시를 적극 사용합니다.
• 안전한 임계 영역도 없고, volatile도 사용하지 않기 때문에 멀티스레드 상황에는 사용할 수는 없습니다. 단일 스레드가 사용하는 경우에 효율적입니다.

VolatileInteger

• volatile을 사용해서 CPU 캐시를 사용하지 않고 메인 메모리를 사용합니다.
• 안전한 임계 영역이 없기 때문에 멀티스레드 상황에는 사용할 수 없습니다.
• 단일 스레드가 사용하기에는 BasicInteger 보다 느립니다. 그리고 멀티스레드 상황에도 안전하지 않습니다.

SyncInteger

• synchronized를 사용한 안전한 임계 영역이 있기 때문에 멀티스레드 상황에도 안전하게 사용할 수 있습니다.
• MyAtomicInteger 보다 성능이 느립니다.

MyAtomicInteger

• 자바가 제공하는 AtomicInteger를 사용합니다.
• 멀티스레드 상황에 안전하게 사용할 수 있습니다.
• 성능도 synchronized, Lock(ReentrantLock)을 사용하는 경우보다 1.5 ~ 2배 정도 빠릅니다.

SyncInteger 와 같은 클래스는 데이터를 보호하기 위해 락을 사용합니다. 여기서 말하는 락은 synchronized, Lock(ReentrantLock)등을 사용하는 것을 말합니다.

락은 특정 자원을 보호하기 위해 스레드가 해당 자원에 대한 접근하는 것을 제한합니다. 락이 걸려 있는 동안 다른 스레드 들은 해당 자원에 접근할 수 없고, 락이 해제될 때까지 대기해야 합니다. 또한 락 기반 접근에서는 락을 획득하고 해제하는 데 시간이 소요됩니다.

CAS 연산

이런 문제를 해결하기 위해 락을 걸지 않고 원자적인 연산을 수행할 수 있는 방법이 있는데, 이것을 CAS(Compare- And-Swap, Compare-And-Set) 연산이라 합니다. 이 방법은 락을 사용하지 않기 때문에 락 프리(lock-free) 기법이라 합니다. 참고로 CAS 연산은 락을 완전히 대체하는 것은 아니고, 작은 단위의 일부 영역에 적용할 수 있습니다. 기본은 락을 사용하고, 특별한 경우에 CAS를 적용할 수 있다고 생각하시면 됩니다.

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으로 설정합니다.
• 자바는 AtomicXxx 의 compareAndSet() 메서드를 통해 CAS 연산을 지원합니다.

실행 결과

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

compareAndSet(0, 1)
atomicInteger 가 가지고 있는 값이 현재 0이면 이 값을 1로 변경하라는 매우 단순한 메서드입니다.

만약 atomicInteger의 값이 현재 0이라면 atomicInteger의 값은 1로 변경됩니다. 이 경우 true를 반환합니다.
만약 atomicInteger의 값이 현재 0이 아니라면 atomicInteger의 값은 변경되지 않습니다. 이 경우 false를 반환합니다.

여기서 가장 중요한 내용이 있는데, 이 메서드는 원자적으로 실행된다는 점입니다. 그리고 이 메서드가 제공하는 기능이 바로 CAS(compareAndSet) 연산입니다.

실행 순서 분석

CAS - 성공 케이스

• 여기서는 AtomicInteger 내부에 있는 value 값이 0이라면 1로 변경하고 싶다.
• compareAndSet(0, 1)을 호출합니다. 매개변수의 왼쪽이 기대하는 값, 오른쪽이 변경하는 값입니다.
• CAS 연산은 메모리에 있는 값이 기대하는 값이라면 원하는 값으로 변경합니다.
• 메모리에 있는 value 의 값이 0이므로 1로 변경할 수 있습니다.
• 그런데 생각해보면 이 명령어는 2개로 나누어진 명령어입니다. 따라서 원자적이지 않은 연산처럼 보입니다.

1. 먼저 메인 메모리에 있는 값을 확인합니다.
2. 해당 값이 기대하는 값(0)이라면 원하는 값(1)으로 변경합니다.

CPU 하드웨어의 지원
CAS 연산은 이렇게 원자적이지 않은 두 개의 연산을 CPU 하드웨어 차원에서 특별하게 하나의 원자적인 연산으로 묶어서 제공하는 기능입니다. 이것은 소프트웨어가 제공하는 기능이 아니라 하드웨어가 제공하는 기능입니다. 대부분의 현대 CPU들은 CAS 연산을 위한 명령어를 제공합니다.

CPU는 다음 두 과정을 묶어서 하나의 원자적인 명령으로 만들어버립니다. 따라서 중간에 다른 스레드가 개입할 수 없습니다.

1. x001의 값을 확인합니다.
2. 읽은 값이 0이면 1로 변경합니다.

CPU는 두 과정을 하나의 원자적인 명령으로 만들기 위해 1번과 2번 사이에 다른 스레드가 x001의 값을 변경하지 못하게 막습니다. 참고로 1번과 2번 사이의 시간은 CPU 입장에서 보면 아주 잠깐 찰나의 순간이기 때문에 성능에 큰 영향을 끼치지 않습니다.

• value 의 값이 0 1이 되었습니다.
• CAS 연산으로 값을 성공적으로 변경하고 나면 true 를 반환합니다.

CAS - 실패 케이스

• CAS 연산은 메모리에 있는 값이 기대하는 값이라면 원하는 값으로 변경합니다.
• 여기서는 AtomicInteger 내부에 있는 value값이 0이라면 1로 변경합니다.
• 현재 value 의 값이 기대하는 0이 아니라 1이므로 아무것도 변경하지 않습니다.

• CAS 연산으로 값 변경에 실패하면 false를 반환하고, 값은 변경되지 않습니다.

여기까지 듣고 보면 CAS 연산을 사용하면, 1. 기대하는 값을 확인하고 2. 값을 변경하는 두 연산을 하나로 묶어서 원자적으로 제공한다는 것은 이해했을 것입니다. 그런데 이 기능이 어떻게 락을 일부 대체할 수 있다는 것일까요?

AtomicInteger가 제공하는 incrementAndGet() 메서드가 어떻게 CAS 연산을 활용해서 락 없이 만들어졌는지 직접 구현해보겠습니다.

public class CasMainV2 {

    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(0);

        int resultValue1 = incrementAndGet(atomicInteger);
        System.out.println("resultValue1 = " + resultValue1);

        int resultValue2 = incrementAndGet(atomicInteger);
        System.out.println("resultValue2 = " + resultValue2);
    }

    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;
    }

    private static void log(String message) {
        System.out.println(Thread.currentThread().getName() + " -> " + message);
    }
}

여기서 만든 incrementAndGet()은 atomicInteger 내부의 value 값을 하나 증가하는 메서드입니다. atomicInteger도 이 메서드를 제공하지만, 여기서는 이해를 위해 직접 구현해보겠습니다.

CAS 연산을 사용하면 여러 스레드가 같은 값을 사용하는 상황에서도 락을 걸지 않고, 안전하게 값을 증가시킬 수 있습니다. 여기서는 락을 걸지 않고 CAS 연산을 사용해서 값을 증가시켰습니다.

• getValue = atomicInteger.get()을 사용해서 value 값을 읽습니다.
• compareAndSet(getValue, getValue + 1)을 사용해서, 방금 읽은 value값이 메모리의 value값과 같다면 value 값을 하나 증가시킵니다. 여기서 CAS 연산을 사용합니다.
• 만약 CAS 연산이 성공한다면 true를 반환하고 do~while 문을 빠져나옵니다.
• 만약 CAS 연산이 실패한다면 false를 반환하고 do~while 문을 다시 시작합니다.

실행 결과

start value = 0
17:48:20.440 [main] getValue: 0
17:48:20.442 [main] result: true
resultValue1 = 1
17:48:20.442 [main] getValue: 1
17:48:20.442 [main] result: true
resultValue2 = 2

지금은 순서대로 실행되기 때문에, 결과는 다음과 같습니다.

incrementAndGet 첫 번째 실행

• atomicInteger.get()을 사용해서 value 값을 읽습니다. -> getValue는 0입니다.
• compareAndSet(0,1)을 수행합니다. (compareAndSet(getValue, getValue + 1))
• CAS 연산이 성공했으므로 value 값은 0에서 1로 증가하고 true를 반환합니다.
• do~while 문을 빠져나갑니다.

incrementAndGet 두 번째 실행

• atomicInteger.get() 을 사용해서 value 값을 읽습니다. -> getValue는 1입니다.
• compareAndSet(1,2)을 수행합니다. (compareAndSet(getValue, getValue + 1))
• CAS 연산이 성공했으므로 value 값은 1에서 2로 증가하고 true를 반환합니다.
• do~while 문을 빠져나갑니다.

지금은 main 스레드 하나로 순서대로 실행되기 때문에 CAS 연산이 실패하는 상황을 볼 수 없습니다. 우리가 기대하는 실패하는 상황은 연산의 중간에 다른 스레드가 값을 변경해버리는 것입니다. 아래에서는 멀티스레드로 실행해서 CAS 연산이 실패하는 경우에 어떻게 작동하는지 알아보겠습니다.

멀티스레드를 사용해서 중간에 다른 스레드가 먼저 값을 증가시켜 버리는 경우를 알아보겠습니다. 그리고 CAS 연산이 실패하는 경우에 어떻게 되는지 알아보겠습니다. 이 경우에도 값을 정상적으로 증가시킬 수 있을까요?

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개의 스레드가 incrementAndGet()를 호출해서 AtomicInteger 내부의 value값을 동시에 하나씩 증가시킵니다.
• 이때 두 스레드는 incrementAndGet() 메서드를 함께 호출합니다. 여기서 스레드가 동시에 같은 값을 읽고 CAS를 수행하는 상황을 쉽게 만들기위해 중간에 sleep() 코드를 추가했습니다.

실행 결과

start value = 0
18:13:37.623 [ Thread-1] getValue: 0
18:13:37.623 [ Thread-0] getValue: 0
18:13:37.625 [ Thread-1] result: true
18:13:37.625 [ Thread-0] result: false
18:13:37.731 [ Thread-0] getValue: 1
18:13:37.731 [ Thread-0] result: true
AtomicInteger resultValue: 2

실행 결과를 보면 마지막에 AtomicInteger가 정상적으로 2 증가된 것을 확인할 수 있습니다.

AtomicInteger가 제공하는 incrementAndGet() 코드도 앞서 직접 작성한 incrementAndGet() 코드와 똑같이 CAS를 활용하도록 작성되어 있습니다. CAS를 사용하면 락을 사용하지 않지만, 대신에 다른 스레드가 값을 먼저 증가해서 문제가 발생하는 경우 루프를 돌며 재시도를 하는 방식을 사용합니다.

이 방식은 다음과 같이 동작합니다

1. 현재 변수의 값을 읽어온다.
2. 변수의 값을 1 증가 시킬때, 원래 값이 같은지 확인한다. (CAS연산사용)
3. 동일하다면 증가된 값을 변수에 저장하고 종료한다.
4. 동일하지 않다면 다른 스레드가 값을 중간에 변경한 것이므로, 다시 처음으로 돌아가 위 과정을 반복한다.

두 스레드가 동시에 실행되면서 문제가 발생하는 상황을 스레드가 충돌했다고 표현합니다.

이 과정에서 충돌이 발생할 때마다 반복해서 다시 시도하므로, 결과적으로 락 없이 데이터를 안전하게 변경할 수 있습니다. CAS를 사용하는 방식은 충돌이 드물게 발생하는 환경에서는 락을 사용하지 않으므로 높은 성능을 발휘할 수 있습니다. 이는 락을 사용하는 방식과 비교했을 때, 스레드가 락을 획득하기 위해 대기하지 않기 때문에 대기 시간과 오버헤드가 줄어드는 장점이 있습니다.

그러나 충돌이 빈번하게 발생하는 환경에서는 성능에 문제가 될 수 있습니다. 여러 스레드가 자주 동시에 동일한 변수의 값을 변경하려고 시도할 때, CAS는 자주 실패하고 재시도해야 하므로 성능 저하가 발생할 수 있습니다. 이런 상황에서는 반복문을 계속 돌기 때문에 CPU 자원을 많이 소모하게 됩니다.

CAS(Compare-And-Swap)와 락(Lock) 방식의 비교

락(Lock) 방식

• 비관적(pessimistic) 접근법
• 데이터에 접근하기 전에 항상 락을 획득
• 다른 스레드의 접근을 막음
• "다른 스레드가 방해할 것이다"라고 가정

CAS(Compare-And-Swap) 방식

• 낙관적(optimistic) 접근법
• 락을 사용하지 않고 데이터에 바로 접근
• 충돌이 발생하면 그때 재시도
• "대부분의 경우 충돌이 없을 것이다"라고 가정