[LG U+ 유레카 3기] Redis Queue + Scheduler로 선착순 쿠폰(100장) 동시성 해결 실습

🧩 Redis Queue + Scheduler로 선착순 쿠폰(100장) 동시성 해결 실습

❶ 상황 설명

선착순 쿠폰 이벤트는 “동시에 많은 사용자가 몰리는” 대표적인 동시성 문제다.
처음엔 JPA에서 quantity를 그냥 감소시키면, 여러 요청이 동시에 들어올 때 갱신 유실(Lost Update) 때문에 재고가 깨지기 쉽다.
이번 실습에서는 DB 락에만 의존하지 않고, Redis Queue로 요청을 줄 세운 뒤 Scheduler가 순차적으로 발급하는 구조로 선착순 100장을 안정적으로 처리했다.

---

❷ 핵심 아이디어 (한 문장 요약)

신청(apply)은 Redis 큐에 넣기만 하고 빠르게 종료 → 발급(publish)은 스케줄러가 큐에서 꺼내 DB 재고를 감소 → 재고가 0이면 SoldOut 처리

• Producer: apply() → Redis List에 userId를 쌓는다 (대기열 생성)
• Consumer: Scheduler → userId를 pop해서 publish() 실행 (발급 로직)
• 선착순 제한: publish()에서 quantity <= 0 이면 SoldOutException 발생

---

❸ 전체 흐름(디버깅 관점으로 보기)

1) 1000명이 동시에 신청 요청

• Thread 1000개가 동시에 couponService.apply(userId)를 호출
• apply()는 DB를 건드리지 않고 Redis Queue에만 userId를 push
• 즉, “신청 단계”는 빠르게 끝나고 서버는 버틴다

2) Scheduler가 큐를 소비하며 발급

• fixedDelay=100ms 마다 스케줄러가 실행
• 큐에서 userId를 하나씩 pop
• publish(userId)로 DB 재고(quantity)를 1 감소

3) 수량이 0이면 마감

• quantity <= 0 이면 SoldOutException 발생
• Scheduler가 isSoldOut=true로 변경 후 더 이상 발급 로직을 태우지 않음
• 결과적으로 최종 quantity는 0에서 멈춘다

---

❹ 코드 (실습 전체)

✅ Entity: Coupon

package com.mycom.myapp.entity;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Data
@NoArgsConstructor
public class Coupon {
    @Id
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private Long id;
    private String name;
    private int quantity; // 쿠폰 수량

    public Coupon(String name,int quantity) {
        this.name = name;
        this.quantity = quantity;
    }
}

✅ Exception: SoldOutException

package com.mycom.myapp.exception;

// 쿠폰 소진을 의미하는 사용자 정의 예외
public class SoldOutException extends RuntimeException{

    private static final long serialVersionUID = 1L;

    public SoldOutException(String message) {
        super(message);
    }
}

✅ Redis Repository: CouponRedisRepository (Queue)

package com.mycom.myapp.repository;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Repository;
import lombok.RequiredArgsConstructor;

// Redis Queueing 작업 관련 처리
@Repository
@RequiredArgsConstructor
public class CouponRedisRepository {

    private final RedisTemplate<String, String> redisTemplate;

    // queue에 추가 (Producer)
    public void addToQueue(Long userId) {
        redisTemplate.opsForList().rightPush("coupon_queue", String.valueOf(userId));
    }

    // queue에서 꺼내기 (Consumer)
    public Long popFromQueue() {
        String userId = redisTemplate.opsForList().leftPop("coupon_queue");
        return userId != null ? Long.valueOf(userId) : null;
    }

    // queue 크기
    public Long getSize() {
        return redisTemplate.opsForList().size("coupon_queue");
    }
}

✅ JPA Repository: CouponRepository

package com.mycom.myapp.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import com.mycom.myapp.entity.Coupon;

public interface CouponRepository extends JpaRepository<Coupon, Long> {
}

✅ Service Interface

package com.mycom.myapp.service;

// 신청(apply): 사용자를 줄 세움(Redis)
// 발급(publish): 쿠폰 수 감소(DB)
public interface CouponService {
    void apply(Long userId);
    void publish(Long userId);
}

✅ Service 구현: CouponServiceImpl

package com.mycom.myapp.service;

import org.springframework.stereotype.Service;

import com.mycom.myapp.entity.Coupon;
import com.mycom.myapp.exception.SoldOutException;
import com.mycom.myapp.repository.CouponRedisRepository;
import com.mycom.myapp.repository.CouponRepository;

import jakarta.transaction.Transactional;
import lombok.RequiredArgsConstructor;

@Service
@RequiredArgsConstructor
public class CouponServiceImpl implements CouponService {

    private final CouponRepository couponRepository;
    private final CouponRedisRepository couponRedisRepository;

    // Producer: 신청 → Redis Queue에 넣고 끝
    @Override
    public void apply(Long userId) {
        couponRedisRepository.addToQueue(userId);
    }

    // Consumer: 발급 → DB에서 수량 감소
    @Transactional
    @Override
    public void publish(Long userId) {
        Coupon coupon = couponRepository.findById(1L).orElseThrow();

        // 선착순 100개 제한
        if (coupon.getQuantity() <= 0) {
            throw new SoldOutException(coupon.getName() + " 쿠폰이 모두 소진되었습니다.");
        }

        coupon.setQuantity(coupon.getQuantity() - 1);

        System.out.println(
            coupon.getName() + " 발급 완료 : 사용자 : " + userId +
            " 잔여 수량 : " + coupon.getQuantity()
        );
    }
}

✅ Scheduler: CouponScheduler

package com.mycom.myapp.scheduler;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.mycom.myapp.exception.SoldOutException;
import com.mycom.myapp.repository.CouponRedisRepository;
import com.mycom.myapp.service.CouponService;

import lombok.RequiredArgsConstructor;

@Component
@RequiredArgsConstructor
public class CouponScheduler {

    private final CouponRedisRepository couponRedisRepository;
    private final CouponService couponService;

    private boolean isSoldOut = false;

    @Scheduled(fixedDelay = 100) // 0.1초마다 호출
    public void couponEventScheduler() {
        while (true) {
            Long userId = couponRedisRepository.popFromQueue();

            if (userId == null) {
                // 처리할 요청이 없으면 종료 → 다음 스케줄에서 재시도
                break;
            }

            if (isSoldOut) {
                // 마감 이후 요청에 대한 정책(로그/저장/알림 등)은 확장 포인트
                continue;
            }

            try {
                couponService.publish(userId);
            } catch (SoldOutException e) {
                isSoldOut = true;
                System.out.println("선착순 쿠폰이 마감되었습니다!");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

✅ Main: 스케줄러 활성화

package com.mycom.myapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class SpringBootJpaRedisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootJpaRedisApplication.class, args);
    }
}

---

❺ 테스트 코드 (동시 요청 1000명 + 선착순 100개 검증)

테스트는 핵심이 2가지다.
1) apply()는 DB를 안 건드린다 → 따라서 발급 결과는 Scheduler가 소비한 뒤에 검증해야 한다.
2) 테스트마다 coupon_queue를 초기화해야 한다 → Redis는 상태를 남기므로 테스트가 오염된다.

package com.mycom.myapp;

import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

import com.mycom.myapp.entity.Coupon;
import com.mycom.myapp.repository.CouponRepository;
import com.mycom.myapp.service.CouponService;

@SpringBootTest
public class CouponConcurrencyTest {

    @Autowired
    private CouponRepository couponRepository;

    @Autowired
    private CouponService couponService;

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @BeforeEach
    void setUp() {
        couponRepository.save(new Coupon("선착순 쿠폰", 100));
        redisTemplate.delete("coupon_queue");
    }

    @Test
    void queueingTest() throws Exception {
        int threadCount = 1000; // thread 1개 = user 1명
        ExecutorService executorService = Executors.newFixedThreadPool(32);
        CountDownLatch latch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            long userId = i; // 0~999
            executorService.submit(() -> {
                try {
                    couponService.apply(userId);
                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await(); // 신청(큐 적재) 완료 대기

        // Scheduler가 큐를 소비할 시간 부여
        Thread.sleep(10000);

        int finalQuantity = couponRepository.findById(1L).orElseThrow().getQuantity();
        System.out.println("finalQuantity : " + finalQuantity);

        assertEquals(0, finalQuantity);
    }
}

---

❻ 내가 한 실수(중요) - Test 클래스에서 main 실행 시도

마지막에 내가 헷갈렸던 부분이 이거였다:

public SpringBootJpaRedisApplicationTests(String[] args) {
    SpringApplication.run(SpringBootJpaRedisApplication.class, args);
}

이건 JUnit 테스트 클래스에서 main을 직접 실행하려는 코드라서 잘못된 방향이다.
테스트 클래스는 Spring이 알아서 컨텍스트를 띄우도록 @SpringBootTest만 있으면 된다.

✅ 올바른 테스트 클래스 형태

package com.mycom.myapp;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringBootJpaRedisApplicationTests {

    @Test
    void contextLoads() {
        // 컨텍스트 로딩만 확인
    }
}

---

❼  핵심 개념 정리

• Redis Queue: Redis List를 큐처럼 사용(RPUSH + LPOP)해서 대기열을 만든다
• Producer/Consumer: 신청은 빠르게 큐에 적재, 발급은 소비자가 순차 처리
• 동시성 해결 전략: “DB에 동시에 접근” 자체를 줄여서 경쟁을 최소화
• 테스트 포인트: apply는 DB 변화 없음 → Scheduler 소비 후 quantity를 검증해야 함