쿠폰 시스템에서 알아보는 분산락

public class RedisLockService {

    private final RedisTemplate<String, String> redisTemplate;

    public RedisLockService(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
// 특정 키에 대한 락을 획득하려고 시도하는 메서드
// 락을 성공적으로 획득하면 true, 모든 시도가 실패하면 false를 반환
    public boolean acquireLock(String lockKey, String value, long expireTime, int retryCount, long sleepTime) {
        ValueOperations<String, String> ops = redisTemplate.opsForValue();

        // 스핀락: 설정된 재시도 횟수만큼 락 획득 시도
        return IntStream.range(0, retryCount)
                .filter(i -> tryLock(ops, lockKey, value, expireTime))
                .peek(i -> sleep(sleepTime)) // 실패 시 sleep 적용
                .findFirst()
                .isPresent();
    }
// 락 획득 시도하는 메서드
    private boolean tryLock(ValueOperations<String, String> ops, String lockKey, String value, long expireTime) {
        // 다른 스레드에서 잘못된 해제를 방지하기 위해 자신이 설정한 값과 동일한지 확인 한 후 락 해제
        return Boolean.TRUE.equals(ops.setIfAbsent(lockKey, value, expireTime, TimeUnit.SECONDS));
    }

// 락 해제 시도하는 메서드
    public void releaseLock(String lockKey, String value) {
        ValueOperations<String, String> ops = redisTemplate.opsForValue();
        String currentValue = ops.get(lockKey);
        if (value.equals(currentValue)) {
            redisTemplate.delete(lockKey);
        }
    }

// 락 획득 시도간에 일정 시간을 대기하게 만드는 메서드
    private void sleep(long sleepTime) {
        try {
            Thread.sleep(sleepTime);
        } catch (InterruptedException e) {
	        // 현재 스레드의 interrupt 상태를 복구
            Thread.currentThread().interrupt();
        }
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DistributedLock {
    String key();  // lock의 이름(고유값)
    TimeUnit timeUnit() default TimeUnit.SECONDS; //
    long waitTime() default 5L; // lock 획득을 시도하는 최대 시간(ms)
    long leaseTime() default 3L; // lock 획득한 후, 점유하는 최대 시간(ms)
}

@Component
public class TransactionForAspect {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Object proceed(final ProceedingJoinPoint joinPoint) throws Throwable {
        return joinPoint.proceed();
    }
}

@Aspect
@Component
@RequiredArgsConstructor
public class DistributedLockAspect {
	private static final String REDISSON_LOCK_PREFIX = "LOCK_KEY:";
    private final RedissonClient redissonClient;
    private final TransactionForAspect transactionForAspect;

    @Around("@annotation(distributedLock)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

        String lockKey = REDISSON_LOCK_PREFIX;
        DistributedLock lock = method.getAnnotation(DistributedLock.class);
        RLock lock = redissonClient.getLock(lockKey);

		// 락이 성공적으로 획득했는지 여부를 확인하는 용도
        boolean acquired = false;

        try {
            acquired = lock.tryLock(lock.waitTime(), lock.leaseTime(), lock.timeUnit());
            if (acquired) {
                // 락 획득 성공 시, 대상 메서드 실행
                return transactionForAspect.proceed(joinPoint);
            } else {
                // 락 획득 실패 시, 필요한 예외 처리 또는 대체 로직
                throw new IllegalStateException("Lock acquisition failed.");
            }
        } finally {
            // 락 해제
            if (acquired && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

@Service
@RequiredArgsConstructor
public class CouponService {

    private final CouponRepository couponRepository;

	@Transactional // 분산락 적용 X
    public void issueCoupon(Long couponId, Integer quantity) {
        Coupon coupon = couponRepository.findById(couponId).orElseThrow();
        coupon.decrease(quantity); // 쿠폰 수량 감소 (변경 감지(dirty checking))
    }

	@DistributedLock(key = "#couponId") // Redis 분산락 적용 
	public voidissueCouponWithLock(Long couponId, Integer quantity) { 
		Coupon coupon = couponRepository.findById(couponId).orElseThrow();
		coupon.decrease(quantity); // 쿠폰 수량 감소 (변경 감지(dirty checking))
		}
}

@Slf4j
@SpringBootTest
class CouponServiceTest {
    private Long COUPON_ID = 1L;
    private final Integer CONCURRENT_COUNT = 100;

    @Autowired
    CouponService couponService;

    @Autowired
    CouponRepository couponRepository;

    @Test
    @DisplayName("동시에 100명이 쿠폰 발급 : 동시성 문제 발생")
    public void issueCouponTest() throws Exception {
        Long originalQuantity = couponRepository.findById(COUPON_ID).orElseThrow().getQuantity();

        ExecutorService executorService = Executors.newFixedThreadPool(100);
        CountDownLatch latch = new CountDownLatch(CONCURRENT_COUNT);

        for (int i = 0; i < CONCURRENT_COUNT; i++) {
            executorService.submit(() -> {
                try {
                    couponService.issueCoupon(COUPON_ID, 1)
                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await();

        Coupon coupon = couponRepository.findById(COUPON_ID).orElseThrow();
        assertEquals(originalQuantity - CONCURRENT_COUNT, coupon.getQuantity());
    }

    @Test
    @DisplayName("동시에 100명이 쿠폰 발급 : 분산락 적용")
    public void issueCouponWithLockTest() throws Exception {
		Long originalQuantity = couponRepository.findById(COUPON_ID).orElseThrow().getQuantity();

        ExecutorService executorService = Executors.newFixedThreadPool(100);
        CountDownLatch latch = new CountDownLatch(CONCURRENT_COUNT);

        for (int i = 0; i < CONCURRENT_COUNT; i++) {
            executorService.submit(() -> {
                try {
                    couponService.issueCouponWithLock(COUPON_ID, 1)
                } finally {
                    latch.countDown();
                }
            });
        }

        latch.await();

        Coupon coupon = couponRepository.findById(COUPON_ID).orElseThrow();
        assertEquals(originalQuantity - CONCURRENT_COUNT, coupon.getQuantity());
    }
}