@Service
public class AccountService {
    
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        Account from = accountRepository.findById(fromId).orElseThrow();
        Account to = accountRepository.findById(toId).orElseThrow();
        
        if (from.getBalance().compareTo(amount) < 0) {
            throw new IllegalArgumentException("잔액 부족");
        }
        
        from.setBalance(from.getBalance().subtract(amount));
        to.setBalance(to.getBalance().add(amount));
        
        accountRepository.save(from);
        accountRepository.save(to);
        // 정상 종료 → COMMIT, 예외 발생 → ROLLBACK
    }
    
    // 격리 수준 설정
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void calculateTotal(Long orderId) {
        // 트랜잭션 내에서 데이터 일관성 보장
    }
    
    // 읽기 전용 최적화
    @Transactional(readOnly = true)
    public List<Order> getOrders() {
        return orderRepository.findAll();
    }
}

@Repository
public interface ProductRepository extends JpaRepository<Product, Long> {
    
    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT p FROM Product p WHERE p.id = :id")
    Optional<Product> findByIdWithLock(@Param("id") Long id);
}

@Service
public class OrderService {
    
    @Transactional
    public void purchaseProduct(Long productId, int quantity) {
        // SELECT ... FOR UPDATE
        Product product = productRepository.findByIdWithLock(productId)
            .orElseThrow();
        
        if (product.getStock() < quantity) {
            throw new IllegalArgumentException("재고 부족");
        }
        
        product.setStock(product.getStock() - quantity);
        productRepository.save(product);
    }
}

@Entity
public class Product {
    @Id
    private Long id;
    private int stock;
    
    @Version // 낙관적 락 버전 컬럼
    private Long version;
}

@Service
public class OrderService {
    
    @Transactional
    public void purchaseProduct(Long productId, int quantity) {
        try {
            Product product = productRepository.findById(productId).orElseThrow();
            
            if (product.getStock() < quantity) {
                throw new IllegalArgumentException("재고 부족");
            }
            
            product.setStock(product.getStock() - quantity);
            productRepository.save(product);
            // UPDATE ... SET version = version + 1 WHERE id = ? AND version = ?
            
        } catch (OptimisticLockException e) {
            throw new IllegalStateException("다른 사용자가 먼저 구매했습니다.");
        }
    }
    
    @Retryable(
        value = OptimisticLockException.class,
        maxAttempts = 3,
        backoff = @Backoff(delay = 100)
    )
    public void purchaseWithRetry(Long productId, int quantity) {
        purchaseProduct(productId, quantity);
    }
}

@Service
public class TransferService {
    
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        // 락 순서 통일로 데드락 방지
        Long firstId = Math.min(fromId, toId);
        Long secondId = Math.max(fromId, toId);
        
        Account first = accountRepository.findByIdWithLock(firstId);
        Account second = accountRepository.findByIdWithLock(secondId);
        
        Account from = (fromId.equals(firstId)) ? first : second;
        Account to = (fromId.equals(firstId)) ? second : first;
        
        from.withdraw(amount);
        to.deposit(amount);
    }
}