락 메커니즘의 모든 것 - 하드웨어부터 분산 시스템까지

// 소프트웨어로 락 구현 시도 (잘못된 방법)
class BrokenLock {
    private boolean locked = false;

    public void lock() {
        // 문제: 이 코드는 원자적이지 않다!
        while (locked) {
            // 대기
        }
        locked = true;  // 여러 스레드가 동시에 실행 가능!
    }

    public void unlock() {
        locked = false;
    }
}

// 하드웨어가 제공하는 원자 명령어
bool test_and_set(bool *target) {
    bool old_value = *target;
    *target = true;
    return old_value;
    // 이 세 줄이 원자적으로 실행됨 (중간에 끼어들 수 없음)
}

class TASLock {
    bool locked = false;

    void lock() {
        // old_value가 false일 때까지 반복 (락 획득 성공)
        while (test_and_set(&locked)) {
            // 바쁜 대기 (busy waiting)
        }
    }

    void unlock() {
        locked = false;
    }
}

// 하드웨어 CAS 명령어
bool compare_and_swap(int *ptr, int expected, int new_value) {
    int actual = *ptr;
    if (actual == expected) {
        *ptr = new_value;
        return true;
    }
    return false;
    // 이 모든 과정이 원자적으로 실행됨
}

import java.util.concurrent.atomic.AtomicInteger;

class CASExample {
    private AtomicInteger value = new AtomicInteger(0);

    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = value.get();
            newValue = oldValue + 1;
        } while (!value.compareAndSet(oldValue, newValue));
        // CAS 실패 시 재시도 (낙관적 접근)
    }
}

class Singleton {
    private static Singleton instance;

    // 잘못된 구현 (Double-Checked Locking 문제)
    public static Singleton getInstance() {
        if (instance == null) {  // 1. 첫 번째 체크
            synchronized (Singleton.class) {
                if (instance == null) {  // 2. 두 번째 체크
                    instance = new Singleton();  // 문제 발생 지점!
                }
            }
        }
        return instance;
    }
}

class Singleton {
    // volatile: 캐시 무시, 항상 메인 메모리에서 읽기/쓰기
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                    // volatile이 메모리 장벽 역할
                    // → 생성자 호출이 완전히 끝난 후에만 instance에 할당
                }
            }
        }
        return instance;
    }
}

class Spinlock {
    private AtomicBoolean locked = new AtomicBoolean(false);

    public void lock() {
        // 락을 획득할 때까지 계속 시도 (바쁜 대기)
        while (!locked.compareAndSet(false, true)) {
            // CPU를 계속 사용하면서 대기!
        }
    }

    public void unlock() {
        locked.set(false);
    }
}

// 좋은 예: 매우 짧은 임계영역
class Counter {
    private Spinlock lock = new Spinlock();
    private int count = 0;

    public void increment() {
        lock.lock();
        count++;  // 단 하나의 명령어 (나노초 단위)
        lock.unlock();
    }
}

// 나쁜 예: 긴 임계영역
class FileProcessor {
    private Spinlock lock = new Spinlock();

    public void processFile() {
        lock.lock();
        readFromDisk();   // 수 밀리초 소요
        parseData();      // 수십 밀리초 소요
        writeToDatabase(); // 수백 밀리초 소요
        lock.unlock();    // 다른 스레드는 계속 CPU 낭비!
    }
}

// Linux 커널에서 실제 사용되는 스핀락
spinlock_t my_lock = SPIN_LOCK_UNLOCKED;

spin_lock(&my_lock);
// 매우 짧은 임계영역 (보통 수십 나노초)
critical_section();
spin_unlock(&my_lock);

-- Shared Lock 획득
SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;

트랜잭션 A: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
  → Shared Lock 획득

트랜잭션 B: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
  → Shared Lock 획득 (가능!)

트랜잭션 C: UPDATE users SET name = 'Kim' WHERE id = 1;
  → Exclusive Lock 시도 → 대기 (Shared Lock이 있음)

-- Exclusive Lock 획득
SELECT * FROM users WHERE id = 1 FOR UPDATE;

트랜잭션 A: SELECT * FROM users WHERE id = 1 FOR UPDATE;
  → Exclusive Lock 획득

트랜잭션 B: SELECT * FROM users WHERE id = 1 FOR UPDATE;
  → 대기 (Exclusive Lock이 있음)

트랜잭션 C: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
  → 대기 (Exclusive Lock이 있음)

        S-Lock  X-Lock
S-Lock    O       X
X-Lock    X       X

O: 호환 (동시 획득 가능)
X: 비호환 (대기 필요)

@Service
@Transactional
public class OrderService {

    // 잘못된 방법: 경쟁 상태 발생
    public void createOrderWrong(Long productId, int quantity) {
        Product product = productRepository.findById(productId);

        if (product.getStock() >= quantity) {
            product.decreaseStock(quantity);  // 여러 트랜잭션이 동시 실행 가능!
            productRepository.save(product);
        }
    }

    // 올바른 방법: Exclusive Lock 사용
    @Query("SELECT p FROM Product p WHERE p.id = :id FOR UPDATE")
    Product findByIdForUpdate(@Param("id") Long id);

    public void createOrderCorrect(Long productId, int quantity) {
        // Exclusive Lock으로 다른 트랜잭션 차단
        Product product = productRepository.findByIdForUpdate(productId);

        if (product.getStock() >= quantity) {
            product.decreaseStock(quantity);
            productRepository.save(product);
        }
    }
}

// 예시: 도큐먼트 업데이트
db.users.updateOne(
    { _id: ObjectId("...") },
    { $set: { name: "Kim" } }
)

// 락 획득 순서:
// 1. 글로벌: IS (Intent Shared)
// 2. 데이터베이스: IX (Intent Exclusive)
// 3. 컬렉션: IX (Intent Exclusive)
// 4. 도큐먼트: X (Exclusive)

글로벌 X-Lock을 걸려면:
→ 모든 데이터베이스 확인
  → 모든 컬렉션 확인
    → 모든 도큐먼트 확인 (수백만 개!)

→ 너무 느림!

글로벌 X-Lock을 걸려면:
→ 글로벌의 Intent Lock만 확인
→ IS나 IX가 있으면 대기
→ 없으면 즉시 획득

→ 빠름!

// 트랜잭션 A
db.users.updateOne({ _id: 1 }, { $set: { name: "Kim" } })
// → 전체 users 컬렉션에 X-Lock!

// 트랜잭션 B
db.users.updateOne({ _id: 2 }, { $set: { name: "Lee" } })
// → 대기 (같은 컬렉션)

// 트랜잭션 A
db.users.updateOne({ _id: 1 }, { $set: { name: "Kim" } })
// → 도큐먼트 1에만 X-Lock

// 트랜잭션 B
db.users.updateOne({ _id: 2 }, { $set: { name: "Lee" } })
// → 도큐먼트 2에 X-Lock (동시 실행 가능!)

10,000개 도큐먼트 동시 업데이트:

Collection-level Lock: 순차 실행 → 10초
Document-level Lock: 병렬 실행 → 0.5초

// JPA Pessimistic Lock
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("SELECT p FROM Product p WHERE p.id = :id")
Product findByIdWithPessimisticLock(@Param("id") Long id);

@Transactional
public void updateStock(Long productId, int quantity) {
    Product product = productRepository.findByIdWithPessimisticLock(productId);
    // 여기서 Exclusive Lock이 걸림
    // 다른 트랜잭션은 대기

    product.decreaseStock(quantity);
    productRepository.save(product);
    // 커밋 시 락 해제
}

SELECT * FROM product WHERE id = 1 FOR UPDATE;
-- 다른 트랜잭션은 이 row를 읽거나 쓸 수 없음

@Entity
public class Product {
    @Id
    private Long id;

    private String name;
    private int stock;

    @Version  // 낙관적 락용 버전 컬럼
    private Long version;
}

@Transactional
public void updateStock(Long productId, int quantity) {
    Product product = productRepository.findById(productId);
    // 락 없이 읽기
    // version = 1

    product.decreaseStock(quantity);
    productRepository.save(product);
    // UPDATE product SET stock = ?, version = version + 1
    //  WHERE id = ? AND version = 1
}

@Transactional
public void updateStockWithRetry(Long productId, int quantity) {
    int maxRetries = 3;
    int attempt = 0;

    while (attempt < maxRetries) {
        try {
            Product product = productRepository.findById(productId);
            product.decreaseStock(quantity);
            productRepository.save(product);
            return;  // 성공
        } catch (OptimisticLockException e) {
            attempt++;
            if (attempt >= maxRetries) {
                throw new RuntimeException("재고 업데이트 실패: 동시성 충돌");
            }
            // 잠시 대기 후 재시도
            Thread.sleep(100);
        }
    }
}

// 서버 A
@Transactional
public void processCoupon(String couponCode) {
    Coupon coupon = couponRepository.findByCode(couponCode);
    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
        coupon.incrementUsage();  // 사용 횟수 증가
        couponRepository.save(coupon);
    }
}

// 서버 B (동시 실행)
@Transactional
public void processCoupon(String couponCode) {
    Coupon coupon = couponRepository.findByCode(couponCode);
    if (coupon.getUsageCount() < couponMaxUsage()) {
        coupon.incrementUsage();  // 중복 사용!
        couponRepository.save(coupon);
    }
}

@Component
public class RedisLockService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    public boolean tryLock(String key, String value, long timeoutSeconds) {
        // SET key value NX EX timeout
        // NX: key가 없을 때만 설정 (원자적)
        // EX: 만료 시간 설정 (초 단위)
        return redisTemplate.opsForValue()
            .setIfAbsent(key, value, timeoutSeconds, TimeUnit.SECONDS);
    }

    public void unlock(String key, String value) {
        // Lua 스크립트로 원자적 삭제
        String script =
            "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "    return redis.call('del', KEYS[1]) " +
            "else " +
            "    return 0 " +
            "end";

        redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(key),
            value
        );
    }
}

@Service
public class CouponService {

    @Autowired
    private RedisLockService lockService;

    public void processCoupon(String couponCode) {
        String lockKey = "coupon:lock:" + couponCode;
        String lockValue = UUID.randomUUID().toString();

        try {
            // 락 획득 시도 (30초 타임아웃)
            if (lockService.tryLock(lockKey, lockValue, 30)) {
                try {
                    // 임계영역
                    Coupon coupon = couponRepository.findByCode(couponCode);
                    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
                        coupon.incrementUsage();
                        couponRepository.save(coupon);
                    }
                } finally {
                    // 반드시 락 해제
                    lockService.unlock(lockKey, lockValue);
                }
            } else {
                throw new RuntimeException("락 획득 실패: 다른 서버가 처리 중");
            }
        } catch (Exception e) {
            log.error("쿠폰 처리 실패", e);
            throw e;
        }
    }
}

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
            .setAddress("redis://localhost:6379");
        return Redisson.create(config);
    }
}

@Service
public class CouponService {

    @Autowired
    private RedissonClient redissonClient;

    public void processCoupon(String couponCode) {
        RLock lock = redissonClient.getLock("coupon:lock:" + couponCode);

        try {
            // 락 획득 시도 (대기 10초, 해제 30초)
            if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
                try {
                    // 임계영역
                    Coupon coupon = couponRepository.findByCode(couponCode);
                    if (coupon.getUsageCount() < coupon.getMaxUsage()) {
                        coupon.incrementUsage();
                        couponRepository.save(coupon);
                    }
                } finally {
                    lock.unlock();
                }
            } else {
                throw new RuntimeException("락 획득 타임아웃");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("락 획득 중단", e);
        }
    }
}

Redis 인스턴스 다운 → 모든 락 사라짐!

// Redisson Redlock 사용
@Service
public class CouponService {

    @Autowired
    private RedissonClient redisson1;
    @Autowired
    private RedissonClient redisson2;
    @Autowired
    private RedissonClient redisson3;

    public void processCoupon(String couponCode) {
        RLock lock1 = redisson1.getLock("coupon:lock:" + couponCode);
        RLock lock2 = redisson2.getLock("coupon:lock:" + couponCode);
        RLock lock3 = redisson3.getLock("coupon:lock:" + couponCode);

        // RedLock: 3개 중 2개 이상 획득해야 성공
        RedissonRedLock redLock = new RedissonRedLock(lock1, lock2, lock3);

        try {
            if (redLock.tryLock(10, 30, TimeUnit.SECONDS)) {
                try {
                    // 임계영역
                    processCouponInternal(couponCode);
                } finally {
                    redLock.unlock();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

// 데드락 발생 예제
class BankAccount {
    private Lock lock = new ReentrantLock();
    private int balance;

    public void transfer(BankAccount target, int amount) {
        this.lock.lock();
        try {
            target.lock.lock();  // 데드락 가능!
            try {
                this.balance -= amount;
                target.balance += amount;
            } finally {
                target.lock.unlock();
            }
        } finally {
            this.lock.unlock();
        }
    }
}

// 사용
BankAccount accountA = new BankAccount(1000);
BankAccount accountB = new BankAccount(1000);

// 스레드 1
accountA.transfer(accountB, 100);  // A락 → B락 대기

// 스레드 2 (동시 실행)
accountB.transfer(accountA, 200);  // B락 → A락 대기

// 데드락!

class BankAccount {
    private final long id;
    private Lock lock = new ReentrantLock();
    private int balance;

    public void transfer(BankAccount target, int amount) {
        // 항상 작은 ID부터 락 획득
        BankAccount first = this.id < target.id ? this : target;
        BankAccount second = this.id < target.id ? target : this;

        first.lock.lock();
        try {
            second.lock.lock();
            try {
                this.balance -= amount;
                target.balance += amount;
            } finally {
                second.lock.unlock();
            }
        } finally {
            first.lock.unlock();
        }
    }
}

public boolean transfer(BankAccount target, int amount) {
    if (this.lock.tryLock()) {
        try {
            if (target.lock.tryLock()) {
                try {
                    this.balance -= amount;
                    target.balance += amount;
                    return true;
                } finally {
                    target.lock.unlock();
                }
            }
        } finally {
            this.lock.unlock();
        }
    }
    return false;  // 실패 시 재시도
}

// 잘못된 코드: 락 해제 누락
public void badMethod() {
    lock.lock();

    if (someCondition) {
        return;  // 락 해제 안 됨!
    }

    doSomething();
    lock.unlock();
}

// 올바른 코드: finally 사용
public void goodMethod() {
    lock.lock();
    try {
        if (someCondition) {
            return;  // finally에서 해제됨
        }
        doSomething();
    } finally {
        lock.unlock();  // 항상 실행됨
    }
}

// 잘못된 구현
public void processWithLock(String key) {
    while (!tryLock(key)) {
        // 무한 대기 가능!
    }
    try {
        doSomething();
    } finally {
        unlock(key);
    }
}

작업 시간: 300ms
동시 요청: 100개
락 요청 시도: 594회
초당 Redis 요청: 2000회

→ Redis 과부하!

// 잘못된 코드
boolean locked = tryLock(key);
try {
    if (locked) {
        doSomething();
    }
} finally {
    unlock(key);  // locked == false일 때도 실행!
}

RLock lock = redissonClient.getLock("myLock");

// waitTime: 락 획득을 대기할 최대 시간
// leaseTime: 락이 자동으로 만료되는 시간
if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
    try {
        doSomething();
    } finally {
        lock.unlock();
    }
} else {
    throw new RuntimeException("락 획득 실패");
}

기존: 초당 2000회 Redis 요청
Pub/Sub: 초당 2회 Redis 요청 (1000배 감소!)

-- Redisson의 락 획득 Lua 스크립트
if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('hset', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;
if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('hincrby', KEYS[1], ARGV[2], 1);
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return nil;
end;
return redis.call('pttl', KEYS[1]);

// 카프카로 동시에 들어오는 중복된 발주를 수신
// → 동일한 발주가 여러 번 등록됨

// 검수/검품 이슈 등록 시:
// - 더블 클릭
// - 네트워크 지연으로 인한 재시도
// → 중복 이슈 생성

// 여러 작업자가 동시에 버튼 클릭
// → 잘못된 재고 트랜잭션 생성

// 1. 어노테이션 정의
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributedLock {
    String key();           // 락 이름 (SpEL 지원)
    long waitTime();        // 대기 시간 (초)
    long leaseTime();       // 임차 시간 (초)
    TimeUnit timeUnit() default TimeUnit.SECONDS;
}

// 2. 사용 예시
@DistributedLock(key = "#lockName", waitTime = 5, leaseTime = 3)
public void shipment(String lockName) {
    // 비즈니스 로직
    // lockName 값이 락 키로 사용됨 (예: "order:12345")
}

@Aspect
@Component
public class DistributedLockAop {
    private final RedissonClient redissonClient;
    private final AopForTransaction aopForTransaction;

    @Around("@annotation(distributedLock)")
    public Object lock(ProceedingJoinPoint joinPoint,
                       DistributedLock distributedLock) throws Throwable {

        // SpEL로 동적 락 키 생성
        String key = CustomSpringELParser.getDynamicValue(
            joinPoint.getSignature(),
            joinPoint.getArgs(),
            distributedLock.key()
        );

        RLock lock = redissonClient.getLock(key);

        try {
            // 락 획득 시도
            boolean available = lock.tryLock(
                distributedLock.waitTime(),
                distributedLock.leaseTime(),
                distributedLock.timeUnit()
            );

            if (!available) {
                throw new InterruptedException("락 획득 실패: " + key);
            }

            // 트랜잭션과 락을 함께 처리
            return aopForTransaction.proceed(joinPoint);

        } catch (InterruptedException e) {
            throw new RuntimeException("락 획득 중단", e);
        } finally {
            // 락 소유자인 경우에만 해제
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

@Component
public class AopForTransaction {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Object proceed(ProceedingJoinPoint joinPoint) throws Throwable {
        return joinPoint.proceed();
    }
}

초기 쿠폰: 100개
동시 요청: 100명

[분산락 미적용]
최종 쿠폰: 21개 (79개만 차감, 21개 중복 차감 실패)

[분산락 적용]
최종 쿠폰: 0개 (정확히 100개 차감)

동일 발주 10건 동시 수신

[분산락 미적용]
등록된 발주: 3~5건 (중복 등록)

[분산락 적용]
등록된 발주: 1건 (정확!)

public void processOrder(String orderId) {
    RLock lock = redissonClient.getLock("order:" + orderId);
    try {
        if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
            try {
                // 비즈니스 로직
                validateOrder(orderId);
                updateStock(orderId);
                createShipment(orderId);
            } finally {
                lock.unlock();
            }
        } else {
            throw new RuntimeException("락 획득 실패");
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException(e);
    }
}

@DistributedLock(key = "'order:' + #orderId", waitTime = 10, leaseTime = 30)
public void processOrder(String orderId) {
    // 비즈니스 로직만 집중!
    validateOrder(orderId);
    updateStock(orderId);
    createShipment(orderId);
}

// Attempting to implement a lock in software (incorrect approach)
class BrokenLock {
    private boolean locked = false;

    public void lock() {
        // Problem: This code is NOT atomic!
        while (locked) {
            // wait
        }
        locked = true;  // Multiple threads can execute this simultaneously!
    }

    public void unlock() {
        locked = false;
    }
}

// Atomic instruction provided by hardware
bool test_and_set(bool *target) {
    bool old_value = *target;
    *target = true;
    return old_value;
    // These three lines execute atomically (cannot be interrupted)
}

class TASLock {
    bool locked = false;

    void lock() {
        // Repeat until old_value is false (lock acquisition success)
        while (test_and_set(&locked)) {
            // busy waiting
        }
    }

    void unlock() {
        locked = false;
    }
}

// Hardware CAS instruction
bool compare_and_swap(int *ptr, int expected, int new_value) {
    int actual = *ptr;
    if (actual == expected) {
        *ptr = new_value;
        return true;
    }
    return false;
    // This entire process executes atomically
}

import java.util.concurrent.atomic.AtomicInteger;

class CASExample {
    private AtomicInteger value = new AtomicInteger(0);

    public void increment() {
        int oldValue, newValue;
        do {
            oldValue = value.get();
            newValue = oldValue + 1;
        } while (!value.compareAndSet(oldValue, newValue));
        // Retry on CAS failure (optimistic approach)
    }
}

class Singleton {
    private static Singleton instance;

    // Incorrect implementation (Double-Checked Locking issue)
    public static Singleton getInstance() {
        if (instance == null) {  // 1. First check
            synchronized (Singleton.class) {
                if (instance == null) {  // 2. Second check
                    instance = new Singleton();  // Problem point!
                }
            }
        }
        return instance;
    }
}

class Singleton {
    // volatile: bypass cache, always read/write from main memory
    private static volatile Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                    // volatile acts as a memory barrier
                    // → instance is assigned only after the constructor completes fully
                }
            }
        }
        return instance;
    }
}

class Spinlock {
    private AtomicBoolean locked = new AtomicBoolean(false);

    public void lock() {
        // Keep trying until the lock is acquired (busy waiting)
        while (!locked.compareAndSet(false, true)) {
            // Continuously uses the CPU while waiting!
        }
    }

    public void unlock() {
        locked.set(false);
    }
}

// Good example: Very short critical section
class Counter {
    private Spinlock lock = new Spinlock();
    private int count = 0;

    public void increment() {
        lock.lock();
        count++;  // A single instruction (nanosecond scale)
        lock.unlock();
    }
}

// Bad example: Long critical section
class FileProcessor {
    private Spinlock lock = new Spinlock();

    public void processFile() {
        lock.lock();
        readFromDisk();   // Takes milliseconds
        parseData();      // Takes tens of milliseconds
        writeToDatabase(); // Takes hundreds of milliseconds
        lock.unlock();    // Other threads waste CPU the entire time!
    }
}

// Spinlock as actually used in the Linux kernel
spinlock_t my_lock = SPIN_LOCK_UNLOCKED;

spin_lock(&my_lock);
// Very short critical section (typically tens of nanoseconds)
critical_section();
spin_unlock(&my_lock);

-- Acquire Shared Lock
SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;

Transaction A: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
  → Acquires Shared Lock

Transaction B: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
  → Acquires Shared Lock (allowed!)

Transaction C: UPDATE users SET name = 'Kim' WHERE id = 1;
  → Attempts Exclusive Lock → Waits (Shared Lock exists)

-- Acquire Exclusive Lock
SELECT * FROM users WHERE id = 1 FOR UPDATE;

Transaction A: SELECT * FROM users WHERE id = 1 FOR UPDATE;
  → Acquires Exclusive Lock

Transaction B: SELECT * FROM users WHERE id = 1 FOR UPDATE;
  → Waits (Exclusive Lock exists)

Transaction C: SELECT * FROM users WHERE id = 1 LOCK IN SHARE MODE;
  → Waits (Exclusive Lock exists)

        S-Lock  X-Lock
S-Lock    O       X
X-Lock    X       X

O: Compatible (can be acquired simultaneously)
X: Incompatible (must wait)

@Service
@Transactional
public class OrderService {

    // Incorrect approach: Race condition occurs
    public void createOrderWrong(Long productId, int quantity) {
        Product product = productRepository.findById(productId);

        if (product.getStock() >= quantity) {
            product.decreaseStock(quantity);  // Multiple transactions can execute simultaneously!
            productRepository.save(product);
        }
    }

    // Correct approach: Use Exclusive Lock
    @Query("SELECT p FROM Product p WHERE p.id = :id FOR UPDATE")
    Product findByIdForUpdate(@Param("id") Long id);

    public void createOrderCorrect(Long productId, int quantity) {
        // Block other transactions with Exclusive Lock
        Product product = productRepository.findByIdForUpdate(productId);

        if (product.getStock() >= quantity) {
            product.decreaseStock(quantity);
            productRepository.save(product);
        }
    }
}

// Example: Document update
db.users.updateOne(
    { _id: ObjectId("...") },
    { $set: { name: "Kim" } }
)

// Lock acquisition order:
// 1. Global: IS (Intent Shared)
// 2. Database: IX (Intent Exclusive)
// 3. Collection: IX (Intent Exclusive)
// 4. Document: X (Exclusive)

To acquire a global X-Lock:
→ Check every database
  → Check every collection
    → Check every document (millions!)

→ Too slow!

To acquire a global X-Lock:
→ Check only the global Intent Lock
→ If IS or IX exists, wait
→ If none, acquire immediately

→ Fast!

// Transaction A
db.users.updateOne({ _id: 1 }, { $set: { name: "Kim" } })
// → X-Lock on the entire users collection!

// Transaction B
db.users.updateOne({ _id: 2 }, { $set: { name: "Lee" } })
// → Waits (same collection)

// Transaction A
db.users.updateOne({ _id: 1 }, { $set: { name: "Kim" } })
// → X-Lock only on document 1

// Transaction B
db.users.updateOne({ _id: 2 }, { $set: { name: "Lee" } })
// → X-Lock on document 2 (can execute concurrently!)