낙관적 락 무한루프 질문

강사님의 강의를 보며 현재 제 프로젝트에 낙관적 락을 적용시켜 보았습니다.

구현하고자 하는 서비스는 쿠폰 발급 서비스이며, DB 구조는
user 1 : N user_coupon N : 1 coupon 입니다.

@Transactional
public void issueCoupon(CouponIssueParam param, User user) {
    // 쿠폰 조회
    Coupon coupon = getCoupon(param.getCouponId());

    // 쿠폰 발급
    UserCoupon userCoupon = UserCoupon.CreateUserCoupon(coupon, user);

    userCouponQueryService.saveUserCoupon(userCoupon);
}

public static UserCoupon CreateUserCoupon(Coupon coupon, User user) {
    // 쿠폰 검증
    coupon.validateCoupon();

    // 재고 감소
    coupon.decreaseQuantity();

    return UserCoupon.builder()
            .coupon(coupon)
            .user(user)
            .build();
}

위 코드와 같이 유저가 특정 쿠폰 Id 를 통해 쿠폰 발급 요청을 하고, 중간 테이블에 관계가 매핑됨으로써 쿠폰 발급이 이루어집니다.

public void validateCoupon() {
    if(this.stockStatus.equals(StockStatus.OUT_OF_STOCK)) throw new IllegalArgumentException("쿠폰이 매진되었습니다.");
    if(this.expiredAt.isBefore(LocalDateTime.now())) throw new IllegalArgumentException("쿠폰이 만료되었습니다.");
}

이때 user_coupon 생성 전 쿠폰의 매진 및 만료 상태에 따라 예외를 던지는 검증 메서드가 존재합니다.

public void decreaseQuantity() {
    this.remainQuantity = this.remainQuantity - 1;
    if(this.remainQuantity <= 0){
        this.stockStatus = StockStatus.OUT_OF_STOCK;
    }
}

추가로 쿠폰 내부에 재고가 감소하는 메서드가 존재하며 0에 다다를 경우 상태값을 변경해줍니다.

이때 동시성 이슈가 발생하는 이유는 user_coupon 을 insert 하면서, 부모 테이블인 coupon 의 재고를 update 하는 과정에서 발생하는 것으로 파악했습니다.

이에 쿠폰 발급 초기에 coupon 을 조회할 때

@Lock(LockModeType.OPTIMISTIC)
@Query("select c from Coupon c where c.id = :couponId and c.isDeleted = false")
Optional<Coupon> findOneCouponByCouponId(@Param("couponId") Long couponId);

이처럼 낙관적 락 어노테이션을 달아주었으며

@Component
@RequiredArgsConstructor
public class OptimisticLockFacade {

    private final CouponService couponService;

    public void issueCoupon(CouponIssueParam param, User user) throws InterruptedException {
        while (true) {
            try {
                couponService.issueCoupon(param, user);
                break;
            } catch (Exception e) {
                Thread.sleep(50); // 재시도 전 잠시 대기
            }
        }
    }
}

위와 같이 퍼사드 클래스를 생성하였습니다.

@Test
@DisplayName("쿠폰 여러 명 발급")
void 쿠폰_여러_명_발급() throws InterruptedException {
    int threadCount = 1000;
    ExecutorService executorService = Executors.newFixedThreadPool(32);
    CountDownLatch latch = new CountDownLatch(threadCount);

    for (int i = 0; i < threadCount; i++) {
        final int threadNumber = i + 1;
        int key = i;
        executorService.submit(() -> {
            try {
                optimisticLockFacade.issueCoupon(param, users.get(key));
                System.out.println("Thread " + threadNumber + " - 성공");

            } catch (PessimisticLockingFailureException e) {
                System.out.println("Thread " + threadNumber + " - 락 충돌 감지");

            } catch (Exception e) {
                System.out.println("Thread " + threadNumber + " - " + e.getMessage());

            } finally {
                latch.countDown();
            }
        });
    }

    latch.await();
    executorService.shutdown();

    Long count = userCouponRepository.countByCouponId(param.getCouponId());

    assertThat(count).isEqualTo(100);
}

 쿠폰의 재고가 100개며, 1,000 명의 유저가 32개의 스레드 환경에서 쿠폰 발급을 요청할 때 예상되는 발급 쿠폰 수는 100개가 되어야 합니다.

이렇게 낙관적 락을 적용하여 테스트를 수행하니 무한 루프에 빠지게 되었습니다.

무한루프로 인해 테스트가 종료되지 않자, 강제적으로 정지 시킨 후 DB 를 확인했는데 쿠폰의 수는 예상한 대로 100개가 생성된 것을 확인할 수 있었습니다.

그런데 왜 메서드가 종료되지 않고 무한루프가 돌아간 것인지 이유를 모르겠습니다.

public void issueCoupon(CouponIssueParam param, User user) throws InterruptedException {
    while (true) {
        try {
            couponService.issueCoupon(param, user);
            break;
        } catch (IllegalArgumentException e) {
            System.out.println("쿠폰 발급 실패: " + e.getMessage());
            break;
        } catch (Exception e) {
            Thread.sleep(50); // 재시도 전 잠시 대기
        }
    }
}

혹시나 하여, 쿠폰 발급 로직에 쿠폰이 매진이 될 경우 예외를 던지는 검증 메서드가 존재했고 이에 퍼사드 클래스에서 해당 예외를 잡아내면 루프를 빠져나오게 설정했습니다.

이렇게 구현하니 테스트는 성공적으로 통과하였습니다.

현재 제가 구현한 서비스 구성에서는 이런식으로 접근하는 게 맞는 걸까요 ?