🚚 재고 감소에 따른 동시성 문제 - 비관적락

디하·2024년 9월 1일

bucket📦

목록 보기

10/10

e-commerce 프로젝트를 만들며 동시에 다수의 주문이 들어올때 100개의

1. 🪝 문제점

프로젝트의 주요 기능 중 하나인 재고 관리 시스템에서 동시에 다수의 주문이 들어올 때 재고가 정확히 감소하지 않는 문제가 발생
초기 테스트에서 100개의 재고에 대해 100건의 주문을 처리하는 동안 일부 재고가 남는 현상이 발견됨 (예상 남은 재고: 0, 실제 남은 재고: 2)

2. 해결과정

1) rock 처리

처음으로 생각했던 방법은 아무래도 Race Condition 문제로 재고가 제대로 감소 되지 않는 현상이라 생각을 했다

🛸 Race Condition : 여러 사용자가 동시에 같은 상품을 주문하는 경우, 재고 수량을 감소시키는 작업이 동시에 이루어질 때, 두개의 트랜잭션이 동시에 같은 재고 데이터에 접근하여 갱신을 시도하여 한 트랙젝션이 다른 트랜젝션 결과를 덮어 쓸 가능성이 있다
-> 일부 주문이 잘못 처리되거나 재고 수량이 정확하게 감소하지 않는 레이스 컨디션 문제가 발생할 수 있다

그래서 단순히 낙관적락/ 비관적락 처럼 락처리를 하면 해결이 되겠지라고 생각을 했었다

하지만, 기존 로직에 락처리를 해줬는데도 재고감소가 올바르지 않게 되는 오류는 지속적으로 발생되었다 .. 🤯

<비관적락 처리한 코드>


@Transactional
    public CommonResponseDto<Object> createOrder(CustomUserDetails customUserDetails, OrderRequestDto orderRequestDto) {
        // 유저 확인
        String email = customUserDetails.getEmail();
        Users user = userRepository.findByEmail(email)
                                   .orElseThrow(() -> new NotFoundException(ErrorCode.USER_NOT_FOUND));

        // 상품 확인
        DessertItem dessertItem = dessertItemRepository.findById(orderRequestDto.getDessertId())
                                                       .orElseThrow(() -> new NotFoundException(ErrorCode.ITEM_NOT_FOUND));

  



        // 재고 감소
        stockLockService.decreaseStock(dessertItem.getStock.getId(), orderRequestDto.getCount(), dessertItem);



        OrderItem orderItem = OrderItem.builder()
                                       .orderPrice(dessertItem.getPrice())
                                       .count(orderRequestDto.getCount())
                                       .dessertItem(dessertItem)
                                       .build();


        Orders order = Orders.builder()
                             .users(user)
                             .orderStatus(OrderStatus.ORDER_COMPLETED) // 기본값 설정
                             .orderDate(LocalDateTime.now())
                             .orderItems(Collections.singletonList(orderItem))
                             .deliveryAddress(orderRequestDto.getDeliveryAddress())
                             .build();

        orderItemRepository.save(orderItem);
        // 주문 항목을 주문에 추가
        order.addOrderItem(orderItem);
        orderRepository.save(order);


        return commonService.successResponse(SuccessCode.EXAMPLE_SUCCESS.getDescription(), HttpStatus.OK, null);
    }


    @Transactional(propagation = Propagation.REQUIRED) // 이 메소드 호출 시 상위 트랜잭션을 이어 받음
    public Stock decreaseStock(Long stockId, int amount, DessertItem dessertItem) {
        // 비관적 락을 사용하여 재고를 가져옴
        Stock stock = stockRepository.findByStockIdWithPessimisticLock(stockId)
                                     .orElseThrow(() -> new NotFoundException(ErrorCode.OUT_OF_STOCK));

        stock.decreaseStock(amount, dessertItem);


        return stockRepository.saveAndFlush(stock);
    }


    public void decreaseStock(int amount , DessertItem dessertItem) {
        if (this.stockAmount < amount) {
            throw new OutOfStockException(ErrorCode.OUT_OF_STOCK);

        }
        this.stockAmount -= amount;
        this.sellAmount += amount;
        this.dessertItem = dessertItem;
        log.info("재고 감소: stockId={}, 감소량={}, 남은 재고={}", id, amount, stockAmount);
    }

로직을 살펴보면, 주문한 유저를 확인하고 주문한 상품을 확인하고 재고감소가 되고 주문처리가 되는 로직이다

Hibernate: 
    select
        di1_0.dessert_id,
        di1_0.contents,
        di1_0.created_at,
        di1_0.deleted_at,
        di1_0.dessert_name,
        di1_0.dessert_type,
        di1_0.price,
        di1_0.sale_status,
        di1_0.updated_at 
    from
        dessert_item di1_0 
    where
        di1_0.dessert_id=?
Hibernate: 
    select
        s1_0.stock_id,
        di1_0.dessert_id,
        di1_0.contents,
        di1_0.created_at,
        di1_0.deleted_at,
        di1_0.dessert_name,
        di1_0.dessert_type,
        di1_0.price,
        di1_0.sale_status,
        di1_0.updated_at,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    left join
        dessert_item di1_0 
            on di1_0.dessert_id=s1_0.dessert_id 
    where
        s1_0.dessert_id=?
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update

for update 가 여러번 먼저 발생하면서 위에 먼저 연달한 발생한 수만큼 재고가 제대로 수정되지 못하는 오류가 발생하고 있었다

재고 : 30

주문 : 30
→ 팔린 수: 26
→ 남은 재고 : 4

Transation 격리 수준의 문제인가 싶어서 격리 수준도 올리고, 락 시도 시간 처리도 조정하면서 여러가지를 조정해보았는데도 해결이 되지 않았다 그러다가 아래가 문제가 된다는 것을 알게 되었다

<🫠 문제의 코드>


 // 상품 확인
        DessertItem dessertItem = dessertItemRepository.findById(orderRequestDto.getDessertId())
                                                       .orElseThrow(() -> new NotFoundException(ErrorCode.ITEM_NOT_FOUND));

  



        // 재고 감소
        stockLockService.decreaseStock(dessertItem.getStock.getId(), orderRequestDto.getCount(), dessertItem);

상품을 조회하고, 재고를 조회하면서 여기서 비관적 락 처리를 하는데 여기서 문제가 생기지 않을까 싶어졌다

Hibernate: 
    select
        di1_0.dessert_id,
        di1_0.contents,
        di1_0.created_at,
        di1_0.deleted_at,
        di1_0.dessert_name,
        di1_0.dessert_type,
        di1_0.price,
        di1_0.sale_status,
        di1_0.updated_at 
    from
        dessert_item di1_0 
    where
        di1_0.dessert_id=?
Hibernate: 
    select
        di1_0.dessert_id,
        di1_0.contents,
        di1_0.created_at,
        di1_0.deleted_at,
        di1_0.dessert_name,
        di1_0.dessert_type,
        di1_0.price,
        di1_0.sale_status,
        di1_0.updated_at 
    from
        dessert_item di1_0 
    where
        di1_0.dessert_id=?
Hibernate: 
    select
        di1_0.dessert_id,
        di1_0.contents,
        di1_0.created_at,
        di1_0.deleted_at,
        di1_0.dessert_name,
        di1_0.dessert_type,
        di1_0.price,
        di1_0.sale_status,
        di1_0.updated_at 
    from
        dessert_item di1_0 
    where
        di1_0.dessert_id=?
Hibernate: 
    select
        di1_0.dessert_id,
        di1_0.contents,
        di1_0.created_at,
        di1_0.deleted_at,
        di1_0.dessert_name,
        di1_0.dessert_type,
        di1_0.price,
        di1_0.sale_status,
        di1_0.updated_at 
    from
        dessert_item di1_0 
    where
        di1_0.dessert_id=?

Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update
Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update

로그를 보면 dessertItem(상품)을 조회하는 쿼리 수 만큼

Hibernate: 
    select
        s1_0.stock_id,
        s1_0.dessert_id,
        s1_0.sell_amount,
        s1_0.stock_amount 
    from
        stock s1_0 
    where
        s1_0.stock_id=? for update

이 코드가 반복되서 연달아 나오고 그 수만큼 재고가 감소가 되지 않았기 때문이다

상품과 재고를 별도의 쿼리로 조회하는 과정에서, 두 쿼리 사이의 시간 차이로 인해 재고에 대한 비관적 락이 적용되기 전에 다른 트랜잭션이 데이터를 변경할 수 있는 문제가 발생한다 판단했다

2) 🚀 통합쿼리

상품을 조회할때 재고도 한꺼번에 조회 할 수 있는 방법을 써서 비관적락이 item 조회시 for update 처리가 될 수 있도록 했다

@Override
public Optional<DessertDto> findDessertItemByPessimisticLock(Long dessertId) {
    QDessertItem qDessertItem = QDessertItem.dessertItem;
    QStock qStock = QStock.stock;

    DessertDto result = queryFactory.select(Projections.constructor(DessertDto.class, qDessertItem, qStock))
                                    .from(qDessertItem)
                                    .join(qDessertItem.stock, qStock).fetchJoin()
                                    .where(qDessertItem.id.eq(dessertId))
                                    .setLockMode(LockModeType.PESSIMISTIC_WRITE)
                                    .fetchOne();

    return Optional.ofNullable(result);
}

상품을 조회할 때 재고를 fetch join으로 함께 가져오면서 비관적 잠금을 걸어 동시성 문제를 해결할 수 있었다

동시에 잠금을 거는 시점의 변경: 통합 쿼리를 사용해 재고 정보를 fetch join 조회하는 동시에 비관적 락을 걸어, 여러 스레드가 동일한 재고 항목에 동시에 접근하지 못하도록 방지

통합 쿼리 적용 후 테스트 결과, 100개의 재고에 대해 100건의 주문이 들어왔을 때 남은 재고가 0개로 정확히 처리되었다 🔥🔥

그리고 Jmeter을 통해 5000건의 주문처리를 해보았고 아래 그림 처림 error 없이 잘 처리 되는 것 까지 확인을 해봤다

디하

🖥️ ⌨️🖱️🩵