동시성 제어는 어떻게 해야할까?

/**
 * 예약 요청 - 기본적인 트랜잭션 적용
 */
async reserveEventWithBasicTransaction(eventId: number, userId: number) {
  const event = await this.eventService.getEventInfo(eventId);
  if (!event) {
    throw new NotFoundException('존재하지 않는 이벤트입니다.');
  }

  return await this.prisma.$transaction(async (tx) => {
    const currentReservationCount = await tx.reservation.count({
      where: { eventId },
    });

    if (currentReservationCount >= event.maxTickets) {
      throw new BadRequestException('매진되었습니다.');
    }

    await tx.reservation.create({
      data: {
        eventId,
        userId,
        reservedAt: new Date(),
        status: 'RESERVED',
      },
    });

    return {
      success: true,
      message: '예약이 완료되었습니다.',
    };
  });
}

import http from 'k6/http'
import { check } from 'k6'
import { Counter, Rate } from 'k6/metrics'

const successfulBookings = new Counter('successful_bookings')
const failedBookings = new Counter('failed_bookings')
const errorRate = new Rate('error_rate')

// 테스트 설정
export const options = {
  scenarios: {
    concurrency_test: {
      executor: 'shared-iterations',
      vus: 150, // 150명이 동시에
      iterations: 150, // 총 150개의 요청
      maxDuration: '1s',
    },
  },
}

const EVENT_ID = 1 // 이벤트 ID (maxTickets: 100)
const BASE_URL = 'http://localhost:3001'

export default function () {
  const userId = Math.floor(Math.random() * 10000) + 1
  const url = `${BASE_URL}/reservation/${EVENT_ID}/${userId}`

  const response = http.post(url)

  // 응답 확인
  const isSuccess = response.status === 200 || response.status === 201

  check(response, {
    'reservation successful': () => isSuccess,
  })

  if (isSuccess) {
    successfulBookings.add(1)
  } else if (response.status === 400) {
    failedBookings.add(1)
  } else {
    errorRate.add(1)
  }
}

interface SummaryData {
  metrics?: {
    successful_bookings?: { values?: { count?: number } }
    failed_bookings?: { values?: { count?: number } }
    [key: string]: any
  }
  [key: string]: any
}

export function handleSummary(data: SummaryData) {
  const successful = Number(data.metrics?.successful_bookings?.values?.count) || 0
  const failed = Number(data.metrics?.failed_bookings?.values?.count) || 0
  const total = successful + failed

  console.log(`${'='.repeat(50)}`)
  console.log(`🔴 동시성 문제 발생 테스트 결과`)
  console.log(`${'='.repeat(50)}`)
  console.log(`총 요청 수: ${total}`)
  console.log(`✅ 성공한 예약: ${successful}`)
  console.log(`❌ 실패한 예약: ${failed}`)

  // 동시성 문제 감지
  if (successful > 100) {
    console.log(`예약 가능 수(100)를 초과하는 예약이 발생했습니다`)
    console.log(`초과 예약 수: ${successful - 100}`)
    console.log(`Race Condition이 발생한 것으로 보입니다.`)
  }

  console.log(`${'='.repeat(50)}`)
}

// 트랜잭션 내부에서의 흐름
1. 현재 예약 수 조회: count = 99
2. 예약 가능 여부 확인: 99 < 100 (예약 가능)
3. 예약 생성
4. 트랜잭션 커밋

시간 →
User A: [count 조회: 99] → [확인: OK] → [예약 생성] → [커밋]
User B:      [count 조회: 99] → [확인: OK] → [예약 생성] → [커밋]
User C:           [count 조회: 99] → [확인: OK] → [예약 생성] → [커밋]
User D:               [count 조회: 99] → [확인: OK] → [예약 생성] → [커밋]
User E:                   [count 조회: 99] → [확인: OK] → [예약 생성] → [커밋]

/**
   * 예약 요청 - 조건부 업데이트
   * 원자적 UPDATE 연산으로 동시성 제어
   */
  async reserveEventWithConditionalUpdate(eventId: number, userId: number) {
    const event = await this.eventService.getEventInfo(eventId);
    if (!event) {
      throw new NotFoundException('존재하지 않는 이벤트입니다.');
    }

    return await this.prisma.$transaction(async (tx) => {
      // 조건부 업데이트: reservedCount < maxTickets일 때만 증가 (MySQL 문법)
      const updateResult = await tx.$executeRaw`
        UPDATE \`Event\`
        SET \`reservedCount\` = \`reservedCount\` + 1
        WHERE id = ${eventId}
          AND \`reservedCount\` < \`maxTickets\`
      `;

      // 업데이트 실패 = 매진
      if (updateResult === 0) {
        throw new BadRequestException('매진되었습니다.');
      }

      // 예약 레코드 생성
      await tx.reservation.create({
        data: {
          eventId,
          userId,
          reservedAt: new Date(),
          status: 'RESERVED',
        },
      });

      return {
        success: true,
        message: '예약이 완료되었습니다.',
      };
    });
  }

/**
   * SERIALIZABLE 격리 수준 사용
   */
  async reserveEventWithSerializable(eventId: number, userId: number) {
    const event = await this.eventService.getEventInfo(eventId);
    if (!event) {
      throw new NotFoundException('존재하지 않는 이벤트입니다.');
    }

    try {
      const result = await this.prisma.$transaction(
        async (tx) => {
          const currentReservationCount = await tx.reservation.count({
            where: { eventId },
          });

          if (currentReservationCount >= event.maxTickets) {
            throw new BadRequestException('매진되었습니다.');
          }

          await tx.reservation.create({
            data: {
              eventId,
              userId,
              reservedAt: new Date(),
              status: 'RESERVED',
            },
          });

          return {
            success: true,
            message: '예약이 완료되었습니다.',
          };
        },
        {
          isolationLevel: 'Serializable', // 격리 수준 설정
          maxWait: 5000, // 락 대기 시간
          timeout: 10000, // 트랜잭션 타임아웃
        },
      );

      return result;
    } catch (error) {
      console.error(error);
      throw new InternalServerErrorException('내부 서버 오류');
    }
  }

[Nest] 28538  - ERROR [ExceptionsHandler]
PrismaClientKnownRequestError:
Transaction failed due to a write conflict or a deadlock.
Please retry your transaction
code: 'P2034'