@Test
        @DisplayName("성공 : 서로 다른 50개 좌석에 대한 동시 예약 시도 -> 모두 성공, 예약 가능 전여 좌석 0.")
        void concurrentReservationsForDifferentSeats() throws InterruptedException, ExecutionException {
            // ============= [Setup 로직] =============
            // 1) 사용자 50명 생성 및 포인트 충전
            List<User> localUsers = new ArrayList<>();
            for (int i = 1; i <= 50; i++) {
                User createdUser = userApplication.registerUser("userName" + i);
                concertReservationApplication.chargeUserPoint(createdUser.getId(), 2000);
                localUsers.add(createdUser);
            }

            // 2) 공연 일정 등록
            ConcertSchedule registeredConcertSchedule = concertReservationApplication.registerConcertSchedule(
                    "concert1", dateTime, reservationStartAt, reservationEndAt, SEAT_PRICE
            );

            // 3) 공연 일정의 좌석 목록 조회
            List<Seat> localSeats = concertReservationApplication.getAvailableSeats(registeredConcertSchedule.getId());

            // ============= [동시 예약 로직] =============
            // given : 50개의 일정한 규칙을 갖는 좌석 생성 및 이에 대한 예약 요청을 수행할 스레드 초기화.
            ExecutorService executor = Executors.newFixedThreadPool(50);
            List<Callable<Boolean>> tasks = new ArrayList<>();

            // 50명 사용자, 50좌석 동시 예약
            for (int i = 1; i <= 50; i++) {
                final int idx = i; // final 변수를 통해 스레드 간 메모리 가시성 확보.
                tasks.add(() -> {
                    try {
                        // 가예약 생성
                        concertReservationApplication.createTemporaryReservation(
                                registeredConcertSchedule.getId(),
                                localUsers.get(idx - 1).getId(),
                                localSeats.get(idx - 1).getId()
                        );
                        // 예약 확정
                        Reservation reservation = concertReservationApplication.confirmReservation(
                                registeredConcertSchedule.getId(),
                                localUsers.get(idx - 1).getId(),
                                localSeats.get(idx - 1).getId()
                        );
                        // 각 스레드 별 작업 결과가 !null && "PAID"인 경우 성공으로 간주
                        return reservation != null && (reservation.getStatus() == ReservationStatus.PAID);
                    } catch (UnavailableRequestException e) {
                        return false; // 실패 처리
                    }
                });
            }
            Collections.shuffle(tasks);

            // when
            List<Future<Boolean>> futures = executor.invokeAll(tasks);
            executor.shutdown();

            int successCount = 0;
            for (Future<Boolean> f : futures) {
                if (f.get()) successCount++;
            }

            ConcertSchedule updatedConcertSchedule = concertReservationApplication.getConcertSchedule(registeredConcertSchedule.getId());

            // then : 스레드 별 실행 결과를 Future<> 를 통해 확인
            assertThat(successCount).isEqualTo(50); // 모든 예약이 성공했는지 확인
            assertThat(updatedConcertSchedule.getAvailableSeatCount()).isEqualTo(0); // 예약 가능 좌석이 0인지 확인
        }

        @Test
        @DisplayName("실패 : 동일한 좌석에 대한 동시 5건 예약 시도 -> 1명만 성공, 4명 실패 && 예약 가능 좌석 49석.")
        void concurrentReservationsForSameSeat() throws InterruptedException, ExecutionException {
            // ============= [Setup 로직] =============
            // 1) 사용자 5명 생성 및 포인트 충전
            List<User> localUsers = new ArrayList<>();
            for (int i = 1; i <= 5; i++) {
                User createdUser = userApplication.registerUser("userName" + i);
                concertReservationApplication.chargeUserPoint(createdUser.getId(), 2000);
                localUsers.add(createdUser);
            }

            // 2) 공연 일정 등록
            ConcertSchedule registeredConcertSchedule = concertReservationApplication.registerConcertSchedule(
                    "concert1", dateTime, reservationStartAt, reservationEndAt, SEAT_PRICE
            );

            // 3) 공연 일정의 좌석 목록 조회
            List<Seat> localSeats = concertReservationApplication.getAvailableSeats(registeredConcertSchedule.getId());
            // given : 5명의 사용자가 동일한 좌석에 대한 예약을 동시에 시도.
            ExecutorService executor = Executors.newFixedThreadPool(5);
            List<Callable<Boolean>> tasks = new ArrayList<>();

            // 5명 사용자, 동일 좌석 동시 예약
            for(int i = 1; i <= 5; i++){
                final int idx = i; // final 변수를 통해 스레드 간 메모리 가시성 확보.
                tasks.add(() -> {
                    try {
                        // 가예약 생성
                        concertReservationApplication.createTemporaryReservation(registeredConcertSchedule.getId(), localUsers.get(idx-1).getId(), localSeats.get(0).getId());
                        // 예약
                        Reservation reservation = concertReservationApplication.confirmReservation(
                                registeredConcertSchedule.getId(), localUsers.get(idx-1).getId(), localSeats.get(0).getId());
                        // 각 스레드 별로 할당된 task(각각 동일 좌석에 대한 예약 수행) 결과가 !null && PAID 인 경우 성공으로 간주 -> true.
                        return reservation != null && (reservation.getStatus() == ReservationStatus.PAID);
                    } catch(UnavailableRequestException | ObjectOptimisticLockingFailureException e){
                        return false; // 실패 처리
                    }
                });
            }

            // when : 5명의 사용자가 동일한 좌석에 대한 예약을 동시에 시도.
            Collections.shuffle(tasks);
            List<Future<Boolean>> futures = executor.invokeAll(tasks);
            
            int successCount = 0;
            int failCount = 0;
            for(Future<Boolean> f : futures){
                if(f.get()) {successCount++;}
                else{failCount++;}
            }

            ConcertSchedule updatedConcertSchedule = concertReservationApplication.getConcertSchedule(registeredConcertSchedule.getId());
            
            // then
            assertThat(successCount).isEqualTo(1);
            assertThat(updatedConcertSchedule.getAvailableSeatCount()).isEqualTo(49);
        }

        @Test
        @DisplayName("성공 : 동시 사용 요청 2건 중 한 건만 성공한다.")
        void onlyOneUsageRequestShouldSuccess_WhenThereAreNUsageRequestForSingleUser()
                throws InterruptedException, ExecutionException {

            // given : 잔액이 0인 사용자가 존재한다.
            User user = userApplication.registerUser("userName");

            // when : 해당 사용자에 대한 2건의 사용 요청이 동시에 발생한다.
            ExecutorService executor = Executors.newFixedThreadPool(2);
            List<Callable<Boolean>> tasks = new ArrayList<>();
            for(int i = 0; i < 2; i++){
                tasks.add(() -> {
                    try{
                        concertReservationApplication.useUserPoint(user.getId(), 1000);
                        return true;
                    } catch(UnavailableRequestException e){
                        return false;
                    }
                });
            }

            Collections.shuffle(tasks);
            List<Future<Boolean>> futures = executor.invokeAll(tasks);
            AtomicInteger successCount = new AtomicInteger(0);

            for(Future<Boolean> f : futures){
                if(f.get()) successCount.incrementAndGet();
            }

            UserPointBalance updatedUserPointBalance = concertReservationApplication.getUserPointBalance(user.getId());

            // then : 1건만 성공하고 1건은 실패한다. 이에 따라 해당 사용자의 잔액은 1,000이다.
            assertThat(successCount.get()).isEqualTo(1);
            assertThat(updatedUserPointBalance.balance().getAmount()).isEqualTo(1000);
        }

        @Test
        @DisplayName("성공 : 동시 충전 요청 2건 중 한 건만 성공한다.")
        void onlyOneChargeRequestShouldSuccess_WhenThereAreNChargeRequestForSingleUser()
                throws ExecutionException, InterruptedException {
            // given : 잔액이 0인 사용자가 존재한다.
            User user = userApplication.registerUser("userName");

            // when : 해당 사용자에 대한 N건의 충전 요청이 동시에 발생한다.
            ExecutorService executor = Executors.newFixedThreadPool(2);
            List<Callable<Boolean>> tasks = new ArrayList<>();
            for(int i = 0; i < 2; i++){
                tasks.add(() -> {
                    try{
                        concertReservationApplication.chargeUserPoint(user.getId(), 1000);
                        return true;
                    } catch(UnavailableRequestException e){
                        return false;
                    }
                });
            }

            Collections.shuffle(tasks);
            List<Future<Boolean>> futures = executor.invokeAll(tasks);
            AtomicInteger successCount = new AtomicInteger(0);

            for(Future<Boolean> f : futures){
                if(f.get()) successCount.incrementAndGet();
            }

            UserPointBalance updatedUserPointBalance = concertReservationApplication.getUserPointBalance(user.getId());

            // then : 1건만 성공하고 1건은 실패한다. 이에 따라 해당 사용자의 잔액은 1,000이다.
            assertThat(successCount.get()).isEqualTo(1);
            assertThat(updatedUserPointBalance.balance().getAmount()).isEqualTo(1000);
        }

@Entity
@Table(name = "CONCERTSCHEDULE")
@Getter
public class ConcertScheduleJpaEntity extends BaseJpaEntity{

    @Id
    @Column(name = "concert_schedule_id")
    private String concertScheduleId;
    private String concertId;
    private int availableSeatsCount;
    private LocalDateTime datetime;
    private LocalDateTime reservationStartAt;
    private LocalDateTime reservationEndAt;

    @Version
    private long version; // Row 단위 Optimistic Locking을 위한 Version 필드.
    
    ...

    public ConcertScheduleJpaEntity updateFromDomain(ConcertSchedule domain) {
        this.concertScheduleId = domain.getId();
        this.concertId = domain.getConcertId();
        this.datetime = domain.getDateTime();
        this.reservationStartAt = domain.getReservationStartAt();
        this.reservationEndAt = domain.getReservationEndAt();
        this.availableSeatsCount = domain.getAvailableSeatCount();
        return this;
    }
}

/**
 * Redis Java API 중 하나인 Redisson 연결을 위한 설정 객체.
 */
@Configuration
public class RedissonConfig {

    @Value("${spring.data.redis.host}")
    private String redisHost;

    @Value("${spring.data.redis.port}")
    private int redisPort;

    private static final String REDISSON_HOST_PREFIX = "redis://";

    @Bean
    public RedissonClient redissonClient() {
        RedissonClient redisson = null;
        Config config = new Config();
        config.useSingleServer().setAddress(REDISSON_HOST_PREFIX + redisHost + ":" + redisPort); // redis://blah:blah 형태.
        redisson = Redisson.create(config);
        return redisson;
    }
}

/**
 * Redisson에서 제공하는 분산 락 활용을 위한 AOP 어노테이션.
 */
@Target(ElementType.METHOD) // 메소드에 적용 가능하도록 설정
@Retention(RetentionPolicy.RUNTIME) // 런타임까지 어노테이션 정보 유지
public @interface RedissonDistributedLock {

    /**
     * 락의 대상이 되는 자원의 식별자. ex. userId, concertScheduleId 등
     */
    String key();

    /**
     * 락이 유지되는 시간 : 별도의 시간 단위 명시 없을 경우 초 단위로 설정.
     */
    TimeUnit timeUnit() default TimeUnit.MILLISECONDS;

    /**
     * 락 획득을 기다리는 시간 (default - 5s). 즉, 락 획득 실패 시 재시도까지 기다리는 시간을 의미.
     */
    long waitTime() default 500L;

    /**
     * 락 임대 시간 (default - 3s)
     * 락을 획득한 이후 leaseTime 이 지나면 락을 해제한다
     */
    long leaseTime() default 1L;
}

@Aspect
@Order(1)
@Component
@Slf4j
@RequiredArgsConstructor
public class RedissonDistributedLockAop {

    private static final String LOCK_PREFIX = "LOCK:";
    private final RedissonClient redissonClient;

    @Around("@annotation(redissonDistributedLock)")
    public Object lock(ProceedingJoinPoint pjp, RedissonDistributedLock redissonDistributedLock) throws Throwable {

        // 1) 락을 걸 대상의 키를 추출
        String paramName = redissonDistributedLock.key();

        // 2) 메서드의 파라미터 이름과 값 추출
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        String[] parameterNames = signature.getParameterNames();  // ex) ["concertId","seatId"]
        Object[] args = pjp.getArgs();                            // ex) ["C123","S45"]

        // 파라미터 이름으로 파라미터 인덱스 찾기
        int paramIndex = -1;
        for (int i = 0; i < parameterNames.length; i++) {
            if (parameterNames[i].equals(paramName)) {
                paramIndex = i;
                break;
            }
        }
        if (paramIndex == -1) {
            throw new IllegalStateException(
                    "해당 이름을 가진 메서드 파라미터가 존재하지 않습니다. : " + paramName + " _ 발생 메서드 : " + signature.getMethod());
        }

        // 3) 락을 걸 대상의 키 생성. ex) LOCK:concertId-C123
        String lockKey = LOCK_PREFIX + ":" + parameterNames[paramIndex] + "-" + args[paramIndex];

        // Redisson의 ReentrantLock 구현체인 RLock 객체 생성
        RLock rLock = redissonClient.getLock(lockKey);
        log.info("[RedissonLockAspect] 다음 키에 대한 락 획득 시도 중입니다.: {}", lockKey);

        boolean currentlyLocked = false; // 현재 락 획득 상태

        try {
            boolean isLockAvailable = rLock.tryLock(redissonDistributedLock.waitTime(), redissonDistributedLock.leaseTime(), redissonDistributedLock.timeUnit());
            if (!isLockAvailable) {
                throw new UnavailableRequestException("다음 자원에 대한 락 획득에 실패하였습니다. 이미 해당 자원에 대한 락이 존재합니다.: " + lockKey);
            }
            rLock.lock(); // 락 실시
            currentlyLocked = true; // 현재 락 획득 상태 변경.
            log.info("[RedissonLockAspect] 다음 키에 대한 락 획득에 성공하였습니다.: {}", lockKey);
            return pjp.proceed(); // 해당 어노테이션이 표기된 메서드 실행. 이때 해당 메서드의 @Transactional 이 적용된다.

        } finally {
            // 메서드 실행 후 락 해제.
            if (currentlyLocked && rLock.isHeldByCurrentThread()) {
                rLock.unlock();
                log.info("[RedissonLockAspect] 다음 키에 대한 락이 해제되었습니다.: {}", lockKey);
            }
        }
    }
}

    /**
     * 특정 공연 일정의 특정 좌석에 대한 가예약을 요청합니다.
     * @param concertScheduleId
     * @param userId
     * @param seatId
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    @RedissonDistributedLock(key = "seatId")
    public Reservation createTemporaryReservation(String concertScheduleId, String userId, String seatId){

        // 해당 좌석 할당 처리(AVAILABLE -> UNAVAILABLE) : 만약 해당 좌석 이미 선점 됐을 경우 여기서 실패.
        Seat assignedSeat = concertService.assignSeatOfConcertSchedule(concertScheduleId, seatId);

        // 가예약 생성 및 반환.
        return reservationService.createReservation(userId, concertScheduleId, seatId);
    }