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

[YuDeokRin]

9️⃣ CAS 락 구현 1

• CAS는 단순한 연산 뿐만 아니라, 락을 구현하는데 사용할 수도 있음.
• Synchronized, Lock(ReentrantLock)없이 CAS를 활용해서 락을 구현해보자.
• 먼저 CAS의 필요성을 이해하기 위해 CAS 없이 직접 락을 구현해보자.

package thread.cas.spinlock;

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

public class SpinLockBad {

    private volatile boolean lock = false;
    
    public void lock() {
        log("락 획득 시도");
        while (true) {
            if (!lock) {
                sleep(100);
                lock = true;
                break;
            } else {
                //락을 획득할 때까지 스핀 대기(바쁜 대기) 한다.
                log("락 획득 실패 - 스핀 대기");
            }
        }
        log("락 획득 완료");
    }
    
    public void unlock() {
        lock = false;
        log("락 반납 완료");
    }    
}

• 구현 원리

  • 스레드가 락을 획득하면 lock의 값이 true가 된다.
  • 스레드가 락을 반납하면 lock의 값이 false가 된다.
  • 스레드가 락을 획득하면 while문을 탈출한다.
  • 스레드가 락을 획득하지 못하면 락을 획득할 때 까지 while문을 계속 반복 실행한다.

• SpinLockMain

package thread.cas.spinlock;

import static util.MyLogger.log;

public class SpinLockMain {

    public static void main(String[] args) {
        SpinLockBad spinLock = new SpinLockBad();

        Runnable task = new Runnable() {

            @Override
            public void run() {
                spinLock.lock();

                try {
                    //critical section
                    log("비즈니스 로직 실행");
                    // sleep(1); //오래 걸리는 로직에서 스핀 락 사용 X
                } finally {
                    spinLock.unlock();
                }

            }
        };

        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");
        t1.start();
        t2.start();
        

    }
}

• 실행 결과
  • 아래의 결과를 보면 Thread-1, Thread-2 둘다 동시에 락을 획득 시도를하고 완료하고 비즈니스 로직 실행도 같이 수행한다.
  • 문제가 발생하는 이유 : 스레드 둘이 동시에 수행되기 때문에 문제가 발생

22:00:14.123 [ Thread-1] 락 획득 시도
22:00:14.123 [ Thread-2] 락 획득 시도
22:00:14.230 [ Thread-1] 락 획득 완료
22:00:14.230 [ Thread-2] 락 획득 완료
22:00:14.231 [ Thread-1] 비즈니스 로직 실행
22:00:14.231 [ Thread-2] 비즈니스 로직 실행
22:00:14.231 [ Thread-2] 락 반납 완료
22:00:14.231 [ Thread-1] 락 반납 완료

• 실행과정 분석

public void lock() {
		log("락 획득 시도");
		while(true) {
				if (!lock) { // 1. 락 사용 여부 확인
						sleep(100); // 문제 상황 확인용, 스레드 대기
						lock = true; // 2. 락의 값 변경
						break; // while 탈출
				} else {
				
					// 락을 획득할 때 까지 스핀 대기(바쁜 대기) 한다.
					log("락 획득 실패 - 스핀 대기");
				}
		}
		log("락 획득 완료");
}

✅ 실행 결과 분석

• lock 의 초기값은 false이다.

• Thread-1과 Thread-2는 동시에 실행된다.

  • Thread-1:lock()을 호출해서 락 획득을 시도한다.
  • Thread-2:lock()을 호출해서 락 획득을 시도한다.

• Thread-1 : if (!lock) 에서 락의 사용 여부를 확인한다. lock의 값이 false 이다.

  • if (!lock) → if (!false) → if (true) 이므로 if 문을 통과한다.

• Thread-2 : if (!lock) 에서 락의 사용 여부를 확인한다. lock 의 값이 false 이다.

  • if (!lock) → if (!false) → if (true) 이므로 if 문을 통과한다.

• Thread-1 : lock = true;를 호출해서 락의 값을 변경한다.

  • 이 시점에 lock 은 false → true 가 된다.

• Thread-2: lock = true; 를 호출해서 락의 값을 변경한다.

  • 이 시점에 lock 은 true -> true 가 된다.

• Thread-1, Thread-2 둘 다 break를 통해 while문을 탈출한다.

• Thread-1, Thread-2 둘 다 락 획득을 완료하고, 비즈니스 로직을 수행한 다음에 락을 반납한다.

위의 과정중 어떤게 문제인걸까 ?
2가지 부분이 원자적이지 않다는 것

1. 락 사용 여부 확인
2. 락의 값 변경

• 이 둘은 한 번에 하나의 스레드만 실행해야 한다.

• 따라서 synchronized 또는 Lock 을 사용해서 두 코드를 동기화해서 안전한 임계 영역을 만들어야 한다.

• 참고로 락을 반납하는 다음 연산은 연산이 하나인 원자적인 연산이다.

• 따라서 이 부분은 여러 스레드가 함께 실행해도 문제가 발생하지 않는다.

public void unlock() {
    lock = false;
    log("락 반납 완료");
}   

🔟 CAS 락 구현 2

• SpinLcok

package thread.cas.spinlock;

import java.util.concurrent.atomic.AtomicBoolean;

import static util.MyLogger.log;

public class SpinLcok {
    private final AtomicBoolean lock = new AtomicBoolean(false);

    public void lock() {
        log("락 획득 시도");
        while (!lock.compareAndSet(false, true)) {
            // 락을 획득할 때 까지 스핀 대기(바쁜 대기) 한다.
            log("락 획득 실패 - 스핀 대기");
        }
        log("락 획득 완료");
    }

    public void unlock() {
        lock.set(false);
        log("락 반납 완료");
    }
}

• CAS 연산을 지원하는 AtomicBoolean을 사용했다.

• 구현 원리

  • 스레드가 락을 획득하면 lock 의 값이 true 가 된다.
  • 스레드가 락을 반납하면 lock 의 값이 false 가 된다.
  • 스레드가 락을 획득하면 while문을 탈출한다.
  • 스레드가 락을 획득하지 못하면 락을 획득할 때 까지 while문을 계속 반복 실행한다.

락을 획득할 때 매우 중요한 부분이 있다. 바로 다음 두 연산을 하나로 만들어야 한다는 점이다.

1. 락 사용 여부 확인
2. 락의 값 변경

• 락을 획득하기 위해 먼저 락의 사용 여부를 확인했을 때 lock 의 현재 값이 반드시 false 여야 한다. true 는 이미 다른 스레드가 락을 획득했다는 뜻이다.

• 따라서 이 값이 false 일 때만 락의 값을 변경할 수 있다.락의 값이 false 인 것을 확인한 시점부터 lock 의 값을 true로 변경할 때 까지 lock 의 값은 반드시 false 를 유지해야 한다.

• 중간에 다른 스레드가 lock 의 값을 true로 변경하면 안된다. 그러면 여러 스레드가 임계 영역을 통과하는 동시성 문제가 발생한다.

• CAS 연산은 두 연산을 하나의 원자적인 연산으로 만들어준다.

• lock.compareAndSet(false, true)

  1. 락 사용 여부 확인 : lock의 값이 false 이면
  2. 락의 값 변경 : lock의 값을 ture로 변경해라.

• SpinLockMain - 코드 변경

package thread.cas.spinlock;
import static util.MyLogger.log;
import static util.ThreadUtils.sleep;
public class SpinLockMain {

		public static void main(String[] args) {
					//SpinLockBad spinLock = new SpinLockBad();
		 		 SpinLock spinLock = new SpinLock();
				 ...
	  }
}

• SpinLockBad 대신에 SpinLock 을 사용하도록 코드를 변경하자.

• 참고로 예제를 단순화 하려고 인터페이스는 사용하지 않았다.

• 실행 결과

22:44:34.350 [ Thread-1] 락 획득 시도
22:44:34.350 [ Thread-2] 락 획득 시도
22:44:34.351 [ Thread-1] 락 획득 완료
22:44:34.351 [ Thread-2] 락 획득 실패 - 스핀 대기
22:44:34.351 [ Thread-1] 비즈니스 로직 실행
22:44:34.351 [ Thread-2] 락 획득 실패 - 스핀 대기
22:44:34.352 [ Thread-1] 락 반납 완료
22:44:34.352 [ Thread-2] 락 획득 완료
22:44:34.352 [ Thread-2] 비즈니스 로직 실행
22:44:34.352 [ Thread-2] 락 반납 완료

• 실행 결과 분석

  • lock 의 초기값은 false 이다.
  • Thread-1 : lock() 을 호출해서 락 획득을 시도한다.
  • Thread-2 : lock() 을 호출해서 락 획득을 시도한다.
  • Thread-1:while (!lock.compareAndSet(false, true))를 사용해서 락의 사용 여부를 확인하면
    서 변경을 시도한다.
    • lock.compareAndSet(false, true)
    • CAS 연산을 사용했다. lock 이 false 면 lock 의 값을 true로 변경한다.
    • lock 의 값이 false 이므로 true로 변경한다. 변경에 성공했기 때문에 true 를 반환한다.
  • while (!true) → while(false)가 되므로 while문을 빠져나온다.
  • 락 획득을 완료한다.

• Thread-2:while (!lock.compareAndSet(false, true))를 사용해서 락의 사용 여부를 확인하면
  서 변경을 시도한다.

  • lock.compareAndSet(false, true)
  • CAS 연산을 사용했다. lock 이 false 면 lock 의 값을 true로 변경한다.
  • lock의 값이true이므로 값을 변경할 수 없다. 변경에 실패했기 때문에 false 를 반환한다.
  • while (!false) → while(true) 가 되므로 while문을 시작한다.
  • 락 획득에 실패하고, 락을 획득할 때 까지 while문을 반복한다.
    • 락 획득 실패 - 스핀 대기 로그가 반복해서 남는다.

• Thread-1 : 비즈니스 로직을 수행하고 lock.set(false) 을 수행해서 락을 반납한다.

• Thread-2 : 락을 획득하고 while문을 탈출한다. 비즈니스 로직을 수행한 다음에 락을 반납한다.

• 원자적인 연산은 스레드 입장에서 쪼갤 수 없는 하나의 연산이다. 따라서 여러 스레드가 동시에 실행해도 안전하다.

• 이렇게 CAS를 사용해서 원자적인 연산을 만든 덕분에 무거운 동기화 작업 없이 아주 가벼운 락을 만들 수 있었다.

• 동기화 락을 사용하는 경우 스레드가 락을 획득하지 못하면 BLOCKED , WAITING 등으로 상태가 변한다. 그리고 또 대기 상태의 스레드를 깨워야 하는 무겁고 복잡한 과정이 추가로 들어간다. 따라서 성능이 상대적으로 느릴 수 있다.

• 반면에 CAS를 활용한 락 방식은 사실 락이 없다. 단순히 while문을 반복할 뿐이다. 따라서 대기하는 스레드도 RUNNABLE상태를 유지하면서 가볍고 빠르게 작동할 수 있다.

✅ CAS 단점

• 하지만 이렇게 반복문과 CAS를 사용해서 락을 대체하는 방식에도 단점이 있다.
• SpinLockMain 코드에 있는 sleep(1) 주석을 풀고 실행해보자.

public void run() {
		spinLock.lock();
		try {
			// critical section
			log("비즈니스 로직 실행");
			sleep(1); // 오래 걸리는 로직에서 스핀 락 사용X
		} finally {
			spinLock.unlock();
		}
}

09:41:04.925 [ Thread-1] 락 획득 시도
09:41:04.925 [ Thread-2] 락 획득 시도
09:41:04.927 [ Thread-1] 락 획득 완료
09:41:04.927 [ Thread-1] 비즈니스 로직 실행
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.927 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-2] 락 획득 실패 - 스핀 대기
09:41:04.928 [ Thread-1] 락 반납 완료
09:41:04.928 [ Thread-2] 락 획득 완료
09:41:04.929 [ Thread-2] 비즈니스 로직 실행
09:41:04.930 [ Thread-2] 락 반납 완료

✅ 스핀 락

• 스레드가 락이 해제되기를 기다리면서 반복문을 통해 계속해서 확인하는 모습이 마치 제자리에서 회전(spin)하는 것처럼 보인다.
• 그래서 이런 방식을 "스핀 락"이라고도 부른다. 그리고 이런 방식에서 스레드가 락을 획득 할 때 까지 대기하는 것을 스핀 대기(spin-wait) 또는 CPU 자원을 계속 사용하면서 바쁘게 대기한다고 해서 바쁜 대기(busy-wait)라 한다.
• 이런 스핀 락 방식은 아주 짧은 CPU 연산을 수행할 때 사용해야 효율적이다. 잘못 사용하면 오히려 CPU 자원을 더 많이 사용할 수 있다.
• 정리하면 "스핀 락"이라는 용어는, 락을 획득하기 위해 자원을 소모하면서 반복적으로 확인(스핀)하는 락 메커니즘을 의미한다. 그리고 이런 스핀 락은 CAS를 사용해서 구현할 수 있다.