JPA 락 전략 — 낙관적 락과 비관적 락으로 동시성을 제어하는 방법

// 재고 차감 로직
public void decreaseStock(Long productId) {
    Product product = productRepository.findById(productId).orElseThrow();
    product.decreaseStock(1); // stock -= 1
}

시간  스레드A                    스레드B
─────────────────────────────────────────────
t1   조회: stock = 10
t2                               조회: stock = 10
t3   stock = 9, UPDATE
t4                               stock = 9, UPDATE  ← 갱신 분실!

@Entity
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private int stock;

    @Version  // 핵심 — 이 필드가 충돌 감지 역할
    private Long version;

    public void decreaseStock(int quantity) {
        if (this.stock < quantity) {
            throw new IllegalStateException("재고가 부족합니다.");
        }
        this.stock -= quantity;
    }
}

-- JPA가 생성하는 실제 SQL
UPDATE product
SET stock = 9, version = 2
WHERE id = 1 AND version = 1   -- 버전이 달라지면 0 rows affected

@Service
@RequiredArgsConstructor
public class ProductService {

    private final ProductRepository productRepository;

    @Retryable(
        retryFor = OptimisticLockingFailureException.class,
        maxAttempts = 3,
        backoff = @Backoff(delay = 100)  // 100ms 간격으로 재시도
    )
    @Transactional
    public void decreaseStock(Long productId) {
        Product product = productRepository.findById(productId).orElseThrow();
        product.decreaseStock(1);
    }

    @Recover  // 모든 재시도가 실패하면 호출
    public void recover(OptimisticLockingFailureException e, Long productId) {
        throw new RuntimeException("재고 차감에 실패했습니다. productId=" + productId, e);
    }
}

public interface ProductRepository extends JpaRepository<Product, Long> {

    // 비관적 쓰기 락
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithPessimisticLock(@Param("id") Long id);

    // 낙관적 락 (강제 버전 증가)
    @Lock(LockModeType.OPTIMISTIC_FORCE_INCREMENT)
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithOptimisticLock(@Param("id") Long id);
}

@Service
@RequiredArgsConstructor
public class PessimisticStockService {

    private final ProductRepository productRepository;

    @Transactional
    public void decreaseStock(Long productId) {
        // SELECT ... FOR UPDATE 실행 — 다른 트랜잭션은 이 행을 수정할 수 없다
        Product product = productRepository
            .findByIdWithPessimisticLock(productId)
            .orElseThrow();

        product.decreaseStock(1);
        // 트랜잭션 커밋 시 락이 해제된다
    }
}

public interface ProductRepository extends JpaRepository<Product, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @QueryHints({
        @QueryHint(name = "jakarta.persistence.lock.timeout", value = "3000")  // 3초
    })
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithPessimisticLock(@Param("id") Long id);
}

트랜잭션A                         트랜잭션B
───────────────────────────────────────────
LOCK product(id=1)
                                   LOCK product(id=2)
LOCK product(id=2) ← 대기
                                   LOCK product(id=1) ← 대기
───────────────────────────────────────────
→ 서로 상대방의 락을 기다리며 교착 상태!

@Transactional
public void transfer(Long fromId, Long toId, int amount) {
    // 항상 작은 ID부터 락을 건다
    Long firstId = Math.min(fromId, toId);
    Long secondId = Math.max(fromId, toId);

    Product first = productRepository.findByIdWithPessimisticLock(firstId).orElseThrow();
    Product second = productRepository.findByIdWithPessimisticLock(secondId).orElseThrow();

    // 비즈니스 로직 수행
    if (fromId.equals(firstId)) {
        first.decreaseStock(amount);
        second.increaseStock(amount);
    } else {
        second.decreaseStock(amount);
        first.increaseStock(amount);
    }
}

public interface LockRepository extends JpaRepository<Product, Long> {

    @Query(value = "SELECT GET_LOCK(:key, :timeout)", nativeQuery = true)
    Integer getLock(@Param("key") String key, @Param("timeout") int timeout);

    @Query(value = "SELECT RELEASE_LOCK(:key)", nativeQuery = true)
    Integer releaseLock(@Param("key") String key);
}

@Component
@RequiredArgsConstructor
public class NamedLockFacade {

    private final LockRepository lockRepository;
    private final ProductService productService;

    @Transactional
    public void decreaseStock(Long productId) {
        try {
            // 락 획득 (타임아웃 3초)
            lockRepository.getLock("STOCK_" + productId, 3);
            // 실제 비즈니스 로직은 별도 트랜잭션에서 수행
            productService.decreaseStock(productId);
        } finally {
            // 반드시 락을 해제한다
            lockRepository.releaseLock("STOCK_" + productId);
        }
    }
}