Day 13 — 오늘 배운 게임 서버 개발 지식 6가지

학습일: 2026년 11월 16일 (01~05과목), 11월 19일 (06과목)
학습 주제: ConcurrentQueue와 Channel, DP, State 패턴, ArrayPool, GROUP BY, 인증과 인가

오늘은 게임 서버 개발에서 자주 사용하는 동시성 컬렉션과 동적 계획법, 상태 관리, 네트워크 버퍼 재사용, 데이터베이스 집계, 인증·인가를 공부했다.

이번 학습에서 반복해서 확인한 것은 기술이 제공하는 기능과 실제 시스템이 보장해야 하는 안정성은 다르다는 점이다.

예를 들어 Channel에 용량 제한을 설정해도 서버 전체 메모리가 자동으로 제한되는 것은 아니며, ArrayPool로 배열을 재사용하더라도 비동기 처리 중 배열의 소유권을 잘못 관리하면 데이터가 오염될 수 있다.

1. 자료구조 — ConcurrentQueue와 Channel의 차이

C#의 Queue<T>는 여러 스레드가 동시에 수정하는 상황에 안전하도록 설계된 컬렉션이 아니다.

여러 스레드가 작업을 추가하고 제거해야 한다면 ConcurrentQueue<T>와 같은 동시성 컬렉션을 고려할 수 있다.

ConcurrentQueue란?

ConcurrentQueue<T>는 여러 Producer와 Consumer가 동시에 접근할 수 있도록 설계된 FIFO 컬렉션이다.

Producer는 작업을 추가하고 Consumer는 작업을 꺼내 처리한다.

다만 작업이 없을 때 비동기적으로 대기하는 기능이나 큐 용량에 따른 Backpressure를 기본적으로 제공하는 것은 아니다.

Channel이란?

Channel<T>는 Producer와 Consumer 사이에서 데이터를 비동기적으로 전달하도록 설계된 기능이다.

대표적인 특징은 다음과 같다.

  • WriteAsync()를 이용한 비동기 쓰기
  • ReadAsync()를 이용한 비동기 읽기
  • Bounded Channel의 용량 제한
  • FullMode에 따른 버퍼가 가득 찼을 때의 처리 정책

예를 들어 게임 서버에서 플레이어 명령을 전달한다고 가정하자.

var channel = Channel.CreateBounded<GameCommand>(
    new BoundedChannelOptions(100)
    {
        FullMode = BoundedChannelFullMode.Wait
    });

이 코드는 최대 100개의 명령을 버퍼에 저장하는 채널을 생성한다.

Backpressure가 필요한 이유

Consumer가 명령을 처리하는 속도보다 Producer가 명령을 추가하는 속도가 빠르면 대기 중인 작업이 계속 쌓일 수 있다.

FullMode.Wait에서는 Channel이 가득 찼을 때 새로운 WriteAsync()가 공간이 생길 때까지 비동기적으로 대기할 수 있다.

여기서 중요한 점은 비동기 대기가 스레드를 계속 차단하는 것과는 다르다는 사실이다.

Capacity를 100으로 제한하면 서버 메모리도 제한될까?

처음에는 Channel 내부 메모리가 계속 증가한다고 생각했다.

하지만 Capacity 100이라면 Channel 내부에 저장되는 요소 수는 100개로 제한된다.

문제는 Channel 외부에 있다.

예를 들어 Channel에 명령 100개가 가득 차 있는데, 추가 HTTP 요청 1,000개가 각각 WriteAsync()를 호출하고 대기한다면 어떨까?

Channel 내부 요소 수는 제한되지만 대기 중인 HTTP 요청과 비동기 작업 상태, 보관된 데이터는 메모리를 사용할 수 있다.

따라서 Bounded Channel은 버퍼 크기를 제한하는 것이지 서버 전체 메모리 사용량을 자동으로 제한하는 것은 아니다.

실제 게임 서버에서는 요청 수 제한, 취소, 타임아웃, Consumer 처리 속도, 작업 유실 방지 등을 함께 고려해야 한다.

또한 메모리 기반 Channel은 서버 종료 후 작업 보존을 보장하지 않는다. 중요한 작업에는 DB나 영속 메시지 큐가 필요할 수 있다.


2. 알고리즘 — DP Memoization과 Tabulation

동적 계획법(Dynamic Programming, DP)은 부분 문제를 해결한 결과를 저장하고 재사용하여 중복 계산을 줄이는 기법이다.

이번에는 Top-down 방식인 Memoization과 Bottom-up 방식인 Tabulation을 비교했다.

Memoization — Top-down

Memoization은 해결하려는 목표 상태에서 시작해 필요한 부분 문제를 재귀적으로 호출한다.

이미 계산한 상태의 결과는 배열이나 Dictionary 같은 캐시에 저장하여 같은 계산을 반복하지 않는다.

Tabulation — Bottom-up

Tabulation은 초기 상태에서 시작하여 작은 부분 문제의 결과를 반복문으로 계산하고 DP 테이블을 채우는 방식이다.

두 방식 모두 상태 정의와 점화식이 중요하지만, 실제 계산을 진행하는 순서가 다르다.

비교MemoizationTabulation

방향 Top-down Bottom-up
기본 방식 재귀 호출과 캐시 반복문과 테이블
계산 대상 필요한 상태를 중심으로 계산 정해진 순서로 상태 계산
추가 고려 사항 재귀 호출 스택 상태 계산 순서

0/1 Knapsack 문제

게임에서 제한된 재화로 보상을 선택한다고 가정하자.

보상필요 재화가치

A 2 4
B 3 5

사용할 수 있는 재화는 3이며, 각 보상은 최대 한 번만 선택할 수 있다.

DP 상태를 다음과 같이 정의할 수 있다.

dp[i, w] = 앞의 i개 보상만 고려했을 때 재화 한도 w로 얻을 수 있는 최대 가치

현재 보상을 선택하지 않는 경우:

dp[i-1, w]

현재 보상을 선택하는 경우:

dp[i-1, w-cost] + value

두 선택지 중 더 큰 값을 사용한다.

이번 복습에서 확인한 계산

재화가 3일 때 B를 선택하지 않으면 A를 선택해 가치 4를 얻을 수 있다.

반면 B를 선택하면 가치 5를 얻는다.

따라서 최종 결과는 5다.

B 미선택 = 4
B 선택   = 5

최대 가치 = 5

왜 이전 행을 참조해야 할까?

현재 보상을 선택할 때 dp[i-1, w-cost]를 사용하는 이유는 현재 보상을 중복 선택하지 않기 위해서다.

이전 단계의 결과는 현재 보상을 아직 포함하지 않으므로, 현재 보상을 한 번 추가할 수 있다.

일반적인 2차원 DP 기반 0/1 Knapsack 구현의 시간 및 추가 공간 복잡도는 O(NW)이다.

Memoization에서는 재귀 호출 스택도 고려해야 하며, 재귀 깊이가 너무 커지면 스택 오버플로 위험이 있다.

실제 게임 서버에서는 제한된 이벤트 재화로 최대 효율의 보상 조합을 계산하는 상황 등에 활용할 수 있다.

다만 DP 계산 자체가 DB 재화 차감이나 보상 지급의 정합성을 보장하지는 않는다.

이번 복습에서는 DP 상태 정의와 선택·미선택 계산을 정확하게 설명했지만, C# 전체 구현은 아직 직접 검증하지 않았다.


3. 디자인 패턴 — State 패턴과 FSM의 차이

게임 서버에서 몬스터 AI를 구현한다고 가정하자.

몬스터는 다음과 같은 상태를 가질 수 있다.

Idle → Move → Attack → Dead

이러한 구조를 표현할 때 FSM과 State 패턴을 사용할 수 있다.

FSM이란?

FSM(Finite State Machine)은 현재 상태와 이벤트에 따라 다음 상태가 결정되는 모델이다.

예를 들어 몬스터가 Idle 상태에서 타깃을 발견하면 Move 상태로 전환할 수 있다.

FSM 자체가 반드시 클래스를 여러 개 만들어야 한다는 의미는 아니다.

간단한 상태 관리라면 enum과 switch만으로도 구현할 수 있다.

State 패턴이란?

State 패턴은 상태별 동작을 객체로 분리하고, 현재 상태 객체를 교체하여 동작을 변경하는 설계 방식이다.

예를 들어 다음 객체들이 있다고 가정하자.

  • IdleState
  • MoveState
  • AttackState
  • DeadState

Monster 객체는 현재 상태를 _state 필드에 저장한다.

상태 전환 시 실제로 무엇이 변경될까?

현재 상태가 Idle이고 타깃을 발견했다고 가정하자.

Monster.Send("TargetFound")
        ↓
IdleState.OnSignal()
        ↓
Monster.ChangeState(MoveState)
        ↓
Monster.Tick()
        ↓
MoveState.Tick()

상태가 변경되더라도 Monster 객체 자체가 새로 생성되는 것은 아니다.

기존 Monster 객체는 유지되고, _state 필드가 참조하는 상태 객체가 변경된다.

따라서 다음 Tick()을 호출하면 실제로 참조 중인 MoveState의 구현이 실행된다.

State 패턴과 Strategy 패턴의 차이

두 패턴 모두 공통 인터페이스와 다형성을 사용할 수 있다.

하지만 목적이 다르다.

구분주요 목적

Strategy 실행할 알고리즘이나 동작 방식 교체
State 현재 상태에 따라 동작하고 상태 전환 처리
FSM 상태와 상태 전환 규칙을 표현하는 모델

State 패턴도 모든 상황에서 필요한 것은 아니다.

몬스터 상태가 단순하다면 enum과 조건문만 사용하는 편이 오히려 이해하기 쉽다.

반면 자동 사냥 AI처럼 상태별 로직과 전환 조건이 복잡하다면 State 패턴을 검토할 수 있다.

실제 서버에서는 잘못된 상태 전환, 멀티스레드 접근, 상태 객체 생성 비용 등도 함께 고려해야 한다.


4. C# 게임 서버 — ArrayPool과 비동기 버퍼 재사용

게임 서버에서 TCP 패킷을 수신하고 처리할 때 배열을 반복적으로 생성하면 관리 힙 할당량과 GC 부담이 증가할 수 있다.

이때 ArrayPool<byte>을 이용해 배열을 빌리고 반환하는 구조를 사용할 수 있다.

ArrayPool의 기본 동작

byte[] buffer =
    ArrayPool<byte>.Shared.Rent(1024);

이 코드는 최소 1024바이트 이상을 저장할 수 있는 배열을 빌린다.

실제 반환된 배열의 길이는 요청한 크기보다 클 수도 있다.

또한 재사용되는 배열이므로 내부 데이터가 0으로 초기화되어 있다고 가정해서는 안 된다.

작업이 끝나면 다음과 같이 반환한다.

ArrayPool<byte>.Shared.Return(buffer);

비동기 작업 중 버퍼를 반환하면?

이번 복습에서 가장 중요했던 부분이다.

다음과 같은 코드가 있다고 가정하자.

byte[] buffer =
    ArrayPool<byte>.Shared.Rent(1024);

Task task = ProcessPacketAsync(buffer);

ArrayPool<byte>.Shared.Return(buffer);

await task;

이 코드는 위험하다.

ProcessPacketAsync()가 아직 배열을 사용 중인데 먼저 풀에 반환하기 때문이다.

배열이 반환되면 다른 작업이 동일한 배열을 빌려 수정할 가능성이 생긴다.

그러면 기존 비동기 작업이 변경된 데이터를 읽거나 쓸 수 있다.

안전한 반환 시점

이번 복습에서는 Return()을 finally로 이동하는 방법을 직접 제시했다.

byte[] buffer =
    ArrayPool<byte>.Shared.Rent(1024);

try
{
    await ProcessPacketAsync(buffer);
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);
}

이 예시는 ProcessPacketAsync()가 버퍼를 사용하는 모든 하위 작업의 완료까지 기다린다는 전제다.

await로 작업이 완료된 후 finally에서 버퍼를 반환하므로 정상 완료와 예외 상황 모두에서 반환할 수 있다.

단, 내부에서 별도의 Fire-and-Forget 작업을 생성해 버퍼를 계속 사용한다면 이 코드만으로 안전성이 보장되지는 않는다.

ArrayPool에서 주의할 점

가장 중요한 것은 배열 참조가 남아 있다는 것과 배열을 사용할 소유권이 있다는 것은 다르다는 점이다.

반환 이후에는 기존 참조로 배열을 사용해서는 안 된다.

또한 배열의 실제 길이와 수신한 패킷 길이를 구분하고, 민감 데이터가 남는 경우에는 버퍼 초기화 정책도 고려해야 한다.

이번에는 반환 시점의 위험을 설명하고 코드를 수정했지만, 실제 컴파일과 동시성 테스트는 하지 않았다.


5. 게임 서버 DB — GROUP BY, COUNT, SUM, HAVING

PostgreSQL에서 유저별 통계를 계산할 때는 GROUP BY와 집계 함수를 사용할 수 있다.

COUNT와 SUM의 차이

이번 학습에서는 기록 개수와 실제 아이템 총수량을 혼동했다.

  • COUNT(*): 행 개수
  • COUNT(column): 해당 컬럼이 NULL이 아닌 행 개수
  • SUM(column): NULL을 제외한 값의 합계

예를 들어 다음 인벤토리 테이블이 있다.

user_iditem_idquantity

1 101 2
1 102 4
2 101 1
2 102 2
3 103 7

유저 1은 아이템 기록이 2행이지만 실제 아이템 수량의 합은 6개다.

따라서 유저별 아이템 총수량을 구하려면 COUNT(*)가 아니라 SUM(quantity)가 필요하다.

GROUP BY와 HAVING

이번 복습에서 직접 작성한 SQL이다.

SELECT
    user_id,
    SUM(quantity) AS total_quantity
FROM user_items
GROUP BY user_id
HAVING SUM(quantity) >= 5;

이 SQL은 유저별로 아이템 수량을 합산하고 총수량이 5개 이상인 유저만 반환한다.

예제 데이터 기준 예상 결과는 다음과 같다.

user_idtotal_quantity

1 6
3 7

ORDER BY를 지정하지 않았으므로 결과 행의 반환 순서는 보장되지 않는다.

WHERE와 HAVING의 차이

WHERE는 그룹화 전에 행을 필터링한다.

HAVING은 그룹화한 이후 집계 결과를 조건으로 필터링한다.

예를 들어 특정 아이템 상태만 대상으로 집계하려면 WHERE로 먼저 필터링할 수 있다.

반대로 총 보유 수량이 5개 이상인 그룹만 조회하려면 HAVING을 사용할 수 있다.

주의해야 할 점

SQL 집계에는 NULL 처리도 중요하다.

COUNT(column)은 NULL을 제외하고, SUM(column)도 NULL을 제외한다.

또한 합산할 값이 전혀 없다면 SUM 결과가 NULL이 될 수 있다.

실제 게임 서버에서는 유저, 인벤토리, 퀘스트처럼 1:N 관계인 테이블을 여러 개 JOIN한 뒤 집계하면 행이 증가하여 합계가 중복 계산될 수 있다.

이 부분은 아직 직접 복습 문제로 검증하지 않았으므로 추가 학습이 필요하다.


6. 서버 기반 지식 — 인증과 인가, 401과 403

게임 서버에서는 로그인에 성공했다는 이유만으로 모든 API에 접근하도록 허용해서는 안 된다.

이번에는 Authentication과 Authorization의 차이를 복습했다.

Authentication이란?

Authentication(인증)은 요청한 주체가 누구인지 확인하는 과정이다.

예를 들어 Bearer 토큰 인증에서는 서버가 전달받은 토큰을 검증하여 사용자를 식별할 수 있다.

Authorization이란?

Authorization(인가)은 인증된 사용자가 특정 API나 데이터에 접근할 권한이 있는지 판단하는 과정이다.

예를 들어 일반 유저는 자신의 인벤토리를 조회할 수 있지만 관리자 전용 재화 지급 API에는 접근할 수 없도록 할 수 있다.

401과 403의 차이

이번 복습에서는 다음 상황을 정확하게 구분했다.

상황일반적인 Bearer 인증 응답

유효한 인증 정보 없음 401 Unauthorized
인증 성공, 권한 부족 403 Forbidden

ASP.NET Core의 일반적인 Bearer 인증 환경에서 인증이 필요한 요청에 유효한 자격 증명이 없다면 Challenge를 통해 401 응답이 발생할 수 있다.

반면 인증되었지만 접근 권한이 없다면 Forbid에 해당하는 403 응답이 발생할 수 있다.

다만 실제 HTTP 응답과 로그인 페이지 이동 등의 처리 방식은 인증 스킴에 따라 달라질 수 있다.

게임 서버에서 추가로 고려할 점

Admin 역할을 가지고 있다고 해서 모든 리소스에 접근할 권한이 자동으로 주어지는 것은 아니다.

예를 들어 플레이어별 인벤토리를 조회할 때는 해당 사용자의 소유권이나 접근 가능 범위를 별도로 검증해야 한다.

따라서 서버에서는 인증과 역할 기반 인가뿐 아니라 리소스 소유권 검사도 중요하다.

이번 복습에서는 401과 403의 구분은 정확하게 설명했으며, 사용자별 리소스 소유권 검사 코드는 아직 검증하지 않았다.


오늘 새롭게 알게 된 점

  1. Bounded Channel은 내부 저장 요소 수를 제한하지만 대기 중인 HTTP 요청의 메모리까지 자동 제한하지는 않는다.
  2. DP의 Memoization과 Tabulation은 계산 순서가 다르지만 상태와 점화식을 재사용한다.
  3. State 패턴에서 상태가 바뀌어도 Context 객체는 유지되고 현재 상태 참조가 변경된다.
  4. ArrayPool의 버퍼는 비동기 작업이 완료된 뒤 반환해야 한다.
  5. GROUP BY 결과의 아이템 총수량에는 COUNT가 아닌 SUM을 사용해야 한다.
  6. 인증은 사용자 식별이고 인가는 접근 권한 판단이다.

추가로 복습할 내용

  • ConcurrentDictionary와 Channel의 동시성 보장 범위
  • Bounded Channel에서 대기 Producer 수를 제한하는 방법
  • DP Memoization의 전체 재귀 호출 과정
  • 0/1 Knapsack의 C# 직접 구현
  • FSM에서 잘못된 상태 전환과 동시성 제어
  • ArrayPool의 버퍼 소유권과 실제 할당량 측정
  • COUNT(column)의 NULL 처리
  • 다중 JOIN에서 집계 결과가 중복되는 문제
  • 관리자 권한과 사용자별 리소스 소유권 검사

Day 13 학습을 마치며

이번 학습에서는 기술의 기본 기능뿐 아니라 각 기술이 보장하지 않는 부분을 이해하는 것이 중요했다.

특히 ArrayPool의 소유권 문제와 Bounded Channel의 대기 Producer 문제는 게임 서버에서 실제 장애로 이어질 수 있는 내용이다.

아직 직접 실행하지 못한 부분도 많으므로, 앞으로는 기억 기반 복습과 코드·SQL 실행 검증을 분리해서 진행하려고 한다.


본문의 모든 C# 코드와 SQL은 학습용 예시이며, 별도의 컴파일·실행·성능 측정은 수행하지 않았다. 회사의 비공개 소스 코드나 고객 데이터는 포함하지 않았다.

Day 12 — 오늘 배운 게임 서버 개발 지식 6가지

학습일: 2026년 11월 14~15일
학습 주제: ConcurrentDictionary, 동적 계획법, Command 패턴, TCP 패킷 파싱, LEFT JOIN, HTTP 기초

게임 서버 개발 압축 학습 12일차에는 기존 5과목에 서버 기반 지식을 추가해 총 6과목을 복습했다.

이번 학습에서 특히 중요했던 것은 하나의 기술이 제공하는 보장과, 실제 비즈니스 로직에서 별도로 구현해야 하는 보장을 구분하는 것이었다.

ConcurrentDictionary를 사용한다고 로그인 보상의 중복 지급이 자동으로 방지되는 것은 아니고, Command 패턴을 적용한다고 구매 명령의 멱등성이 보장되는 것도 아니다.

각 기술의 역할과 내부 동작을 정확하게 이해하는 것이 중요하다는 점을 확인했다.


1. 자료구조 — ConcurrentDictionary와 동시성 컬렉션

C#의 일반적인 Dictionary<TKey, TValue>는 여러 스레드가 동시에 수정하는 상황에서 안전한 사용을 보장하지 않는다.

반면 ConcurrentDictionary<TKey, TValue>는 여러 스레드의 동시 접근을 지원하도록 설계된 컬렉션이다.

게임 서버에서는 접속 중인 플레이어의 세션을 관리하는 등의 작업에 활용할 수 있다.

GetOrAdd는 무엇을 보장할까?

ConcurrentDictionary<long, PlayerSession> sessions = new();

var session = sessions.GetOrAdd(
    100,
    id => new PlayerSession(id));

GetOrAdd는 Key가 이미 존재하면 기존 값을 반환하고, 존재하지 않으면 새로운 값을 추가하여 반환한다.

그런데 동시에 여러 요청이 실행된다면 주의할 점이 있다.

GetOrAdd에 전달한 valueFactory는 여러 번 실행될 수 있다.

예를 들어 로그인 요청 A와 B가 동시에 같은 Key를 등록하려고 한다면 각각 세션 객체를 생성할 수 있다.

하지만 실제 Dictionary에 등록되는 해당 Key의 값은 하나다.

즉, valueFactory의 실행 횟수와 Dictionary에 성공적으로 등록되는 횟수는 다를 수 있다.

TryAdd와 GetOrAdd의 차이

bool added = sessions.TryAdd(
    100,
    new PlayerSession(100));

TryAdd는 새 Key가 추가되었다면 true, 이미 존재하는 Key라서 추가하지 못했다면 false를 반환한다.

따라서 실제로 새로운 세션을 등록한 요청인지 판단할 때 활용할 수 있다.

비교GetOrAddTryAdd

주요 목적 기존 값 조회 또는 새 값 추가 새 Key 등록 시도
반환값 최종 Value 등록 성공 여부 bool
등록 성공 여부 직접 확인 불가 가능
주의점 valueFactory 중복 실행 가능 값 생성 자체는 등록 실패 전에도 발생 가능

ConcurrentDictionary가 로그인 보상의 중복 지급도 막을까?

그렇지는 않다.

ConcurrentDictionary가 보장하는 것은 컬렉션에 대한 동시성 안전성이다.

DB에 골드를 지급하는 작업이나 결제 처리까지 자동으로 원자적으로 묶어주는 것은 아니다.

예를 들어 로그인 요청이 중복 전달되거나 서버가 재시작되는 경우, 메모리에 저장된 세션 정보만으로 보상 지급 이력을 영구적으로 보장하기 어렵다.

따라서 중요한 보상 지급에는 다음과 같은 별도 설계가 필요할 수 있다.

  • 보상 지급 이력의 DB 저장
  • 지급 식별자에 대한 UNIQUE 제약
  • 골드 지급과 지급 기록의 트랜잭션 처리
  • 동일 요청에 대한 멱등성 보장

또한 ConcurrentDictionary에 저장한 PlayerSession 객체의 내부 필드를 여러 스레드가 동시에 수정한다면, 그 객체의 상태 변경은 별도로 동기화해야 할 수 있다.

컬렉션의 동시성 안전성과 비즈니스 작업의 정합성은 서로 다른 문제다.


2. 알고리즘 — Greedy와 동적 계획법(DP)

동적 계획법(Dynamic Programming, DP)은 부분 문제의 결과를 저장하고 재사용하여 중복 계산을 줄이는 알고리즘 설계 기법이다.

이전에 학습한 Greedy 알고리즘과 비교하면 차이를 이해하기 쉽다.

Greedy와 DP의 차이

Greedy는 현재 단계에서 가장 유리한 선택을 한다.

하지만 현재 가장 좋아 보이는 선택이 항상 전체 최적해로 이어지지는 않는다.

반면 DP는 문제의 상태를 정의하고, 필요한 선택지들의 결과를 비교하여 최적해를 계산할 수 있다.

대표적인 문제가 0/1 Knapsack이다.

게임 보상 선택 문제

이벤트 재화가 7개 있고, 다음 보상들이 있다고 가정하자.

보상필요 재화가치

A 4 7
B 3 6
C 5 8

각 보상은 최대 한 번만 선택할 수 있다.

이 경우 A와 B를 선택하면 재화 7개를 모두 사용하여 가치 13을 얻는다.

DP로 이런 문제를 해결하려면 먼저 상태를 정의해야 한다.

DP 상태 정의

dp[i, w]를 다음과 같이 정의할 수 있다.

앞에서부터 i개의 보상만 고려하고, 사용할 수 있는 재화의 한도가 w일 때 얻을 수 있는 최대 가치

여기서 i는 고려한 보상 개수이고, w는 사용 가능한 재화 한도다.

이 값을 계산할 때 현재 보상을 선택하지 않는 경우와 선택하는 경우를 비교한다.

0/1 Knapsack 점화식

현재 보상을 선택하지 않는다면:

dp[i-1, w]

현재 보상을 선택할 수 있다면:

dp[i-1, w-cost] + value

두 경우 중 더 큰 값을 선택한다.

dp[i,w] = max(
    dp[i-1,w],
    dp[i-1,w-cost] + value
)

단, 현재 보상의 비용이 w보다 크다면 그 보상을 선택할 수 없다.

왜 i-1을 사용할까?

이번 복습에서 직접 설명했던 중요한 부분이다.

현재 보상을 선택할 때 dp[i, w-cost]를 사용하면 현재 보상을 이미 포함한 결과를 다시 참조하여 동일 보상을 반복 선택할 위험이 있다.

반면 dp[i-1, w-cost]를 사용하면 현재 보상을 포함하지 않은 이전 단계의 결과에 현재 보상을 한 번만 추가할 수 있다.

따라서 각 보상을 최대 한 번 선택한다는 0/1 Knapsack 규칙을 유지할 수 있다.

DP의 복잡도

보상 개수가 N개이고, 재화 한도가 정수 W라면 일반적인 2차원 테이블 기반 구현은 다음과 같다.

항목복잡도

시간 복잡도 O(NW)
추가 공간 복잡도 O(NW)

DP는 단순히 모든 조합을 직접 나열하는 방식이 아니다. 부분 문제의 결과를 재사용하기 때문에 같은 계산을 반복하지 않을 수 있다.

다만 W가 매우 크면 상태 수가 많아져 CPU와 메모리 사용량이 증가할 수 있다.

게임 서버에서 이벤트 보상 조합이나 제한된 자원 배분을 계산할 때 활용할 수 있지만, 지연에 민감한 실시간 전투 처리에서 큰 DP 계산을 매 요청마다 실행하는 것은 주의해야 한다.

이번 복습에서는 상태 정의와 점화식은 설명할 수 있었지만, C# 전체 구현과 1차원 DP 공간 최적화는 아직 직접 검증하지 않았다.


3. 디자인 패턴 — Command 패턴과 게임 서버 명령 처리

Command 패턴은 실행할 작업을 객체로 표현하고, 요청하는 부분과 실제 실행 로직을 분리하는 디자인 패턴이다.

게임 서버에서 인벤토리의 아이템을 사용하는 작업을 예로 들어보자.

Command 패턴의 세 가지 역할

구성 요소역할

Invoker Command에 실행 요청
Command 필요한 데이터를 보관하고 Receiver에 작업 위임
Receiver 실제 비즈니스 로직 실행

예를 들어 다음 객체가 존재한다고 가정하자.

CommandInvoker
UseItemCommand
InventoryService

실행 흐름은 다음과 같다.

CommandInvoker.RunAsync()
        ↓
UseItemCommand.ExecuteAsync()
        ↓
InventoryService.UseItemAsync()

Command 객체 생성과 실행은 다르다

var inventory = new InventoryService();

ICommand command = new UseItemCommand(
    inventory,
    itemId: 1001,
    count: 1);

var invoker = new CommandInvoker();

await invoker.RunAsync(
    command,
    CancellationToken.None);

위 코드는 인터페이스와 구현 클래스가 정의되어 있다고 가정한 학습용 호출 예시다.

new UseItemCommand(...)는 아이템 사용에 필요한 데이터와 Receiver 참조를 보관할 명령 객체를 생성한다.

이 시점에는 실제 아이템 사용 로직이 수행되지 않는다.

Invoker가 명령 실행을 요청하면 Command의 실행 메서드가 호출되고, Command가 Receiver에 작업을 위임한다.

이렇게 하면 명령 객체를 만들어 두었다가 나중에 실행하거나, 별도의 명령 실행 구조를 구성할 수 있다.

Command 패턴이 트랜잭션과 멱등성을 보장할까?

그렇지 않다.

이 부분은 이번 학습에서 혼동했던 개념이다.

예를 들어 동일한 아이템 구매 Command를 두 번 실행했다고 가정하자.

각 Command가 골드 차감과 아이템 지급을 하나의 DB 트랜잭션으로 처리하더라도, 두 트랜잭션이 모두 성공하면 구매가 두 번 반영될 수 있다.

트랜잭션은 하나의 논리적 작업을 구성하는 DB 변경의 원자성을 보장하는 데 사용된다.

멱등성은 동일한 논리적 요청이 반복되어도 비즈니스 효과가 중복 반영되지 않도록 하는 성질이다.

따라서 Command 패턴만 사용한다고 중복 실행이 방지되지는 않는다.

실제 구매 명령에서는 requestId, UNIQUE 제약, 트랜잭션, 기존 처리 결과 확인 등을 함께 고려해야 한다.

또한 Command 패턴 자체가 작업 큐, 자동 재시도, 명령 영속성까지 제공하는 것은 아니다.

단순히 서비스 메서드 한 번을 호출하는 작업이라면 Command 패턴을 추가하는 것이 오히려 복잡도를 높일 수도 있다.


4. C# 게임 서버 — TCP Length-Prefix 패킷 파싱

TCP는 애플리케이션 메시지의 경계를 보장하지 않는 바이트 스트림 프로토콜이다.

따라서 클라이언트가 하나의 게임 명령을 전송하더라도 서버의 ReadAsync() 한 번에 모든 바이트가 수신된다는 보장은 없다.

Length-Prefix 방식

Length-Prefix는 메시지 앞에 본문 길이를 기록하는 방식이다.

예를 들어 다음과 같은 프로토콜을 정의할 수 있다.

[4바이트 길이 헤더][메시지 본문]

서버는 먼저 헤더를 모두 읽고 본문 길이를 확인한다.

그다음 해당 길이만큼 본문을 수신할 때까지 기다린다.

부분 수신 처리

예를 들어 메시지 본문 길이가 10바이트인데 첫 번째 ReadAsync()에서 6바이트만 수신했다고 가정하자.

이때는 본문이 완성되지 않았으므로 게임 명령을 실행하면 안 된다.

서버는 누적 수신량을 관리하면서 남은 4바이트를 추가로 수신해야 한다.

다만 다음 ReadAsync가 0을 반환했다면 상황이 달라진다.

ReadAsync가 0을 반환한다는 의미

이번 복습에서 처음에는 0을 반환하면 메시지 하나를 모두 수신한 것이라고 잘못 이해했다.

하지만 정상적으로 0바이트보다 큰 버퍼로 읽기를 요청했을 때 NetworkStream.ReadAsync()가 0을 반환하면 일반적으로 TCP 수신 스트림의 끝(EOF)을 의미한다.

즉, 상대방이 송신 방향을 정상적으로 종료하여 더 이상 읽을 데이터가 없다는 뜻이다.

이것은 게임 메시지 하나의 수신 완료와는 전혀 다른 개념이다.

패킷 수신 도중 EOF가 발생하면?

본문 길이가 10바이트인데 6바이트만 수신한 상태에서 EOF가 발생했다면 메시지는 불완전하다.

이때는 이미 스트림의 끝에 도달했으므로 나머지 4바이트가 계속 도착하기를 기다리는 방식으로 처리하면 안 된다.

서버는 불완전한 패킷으로 판단하고 적절한 오류 처리를 수행해야 한다.

반대로 본문 10바이트를 모두 수신한 이후 다음 메시지를 기다리다가 EOF가 발생했다면, 이미 완성된 메시지는 정상적으로 처리할 수 있다.

게임 서버에서 추가로 주의할 점

  • 길이 헤더 자체도 여러 번에 나누어 수신될 수 있다.
  • 최대 패킷 길이를 검증해야 한다.
  • 송신 측과 수신 측의 바이트 순서를 일치시켜야 한다.
  • 불완전한 패킷을 비즈니스 로직에 전달해서는 안 된다.
  • 연결 종료와 네트워크 오류를 구분해야 한다.
  • 높은 트래픽에서는 버퍼 재사용과 메모리 할당 비용을 고려해야 한다.

실제 NetworkStream 수신 루프의 독립적인 C# 구현과 실행 검증은 아직 진행하지 않았다.


5. 게임 서버 DB — INNER JOIN과 LEFT JOIN

관계형 데이터베이스에서는 여러 테이블의 데이터를 연결해서 조회할 때 JOIN을 사용한다.

이번에는 INNER JOIN과 LEFT JOIN, 그리고 ON과 WHERE의 차이를 복습했다.

INNER JOIN과 LEFT JOIN의 차이

INNER JOIN은 JOIN 조건에 매칭되는 행만 반환한다.

LEFT JOIN은 오른쪽 테이블에 매칭되는 행이 없더라도 왼쪽 테이블의 행을 유지한다.

매칭되는 오른쪽 행이 없으면 오른쪽 테이블의 컬럼 값은 NULL이 된다.

게임 서버 유저와 캐릭터 조회

다음 테이블이 있다고 가정하자.

users

user_idnickname

1 Alice
2 Bob
3 Carol

characters

character_iduser_idjob

101 1 Warrior
102 1 Wizard
103 2 Mage

캐릭터가 없는 유저까지 조회하고 싶다면 LEFT JOIN을 사용할 수 있다.

ON 조건에 Wizard를 넣으면?

SELECT
    u.nickname,
    c.job
FROM users u
LEFT JOIN characters c
    ON u.user_id = c.user_id
   AND c.job = 'Wizard'
ORDER BY u.user_id;

결과는 다음과 같다.

nicknamejob

Alice Wizard
Bob NULL
Carol NULL

중요한 점은 ON 조건에 일치하는 캐릭터가 없더라도 왼쪽 테이블의 유저 행은 유지된다는 것이다.

따라서 Bob과 Carol도 조회 결과에 포함된다.

WHERE로 조건을 옮기면?

SELECT
    u.nickname,
    c.job
FROM users u
LEFT JOIN characters c
    ON u.user_id = c.user_id
WHERE c.job = 'Wizard'
ORDER BY u.user_id;

이번에는 Alice만 조회된다.

WHERE가 JOIN 결과를 다시 필터링하기 때문이다.

Bob의 Mage는 Wizard 조건을 만족하지 않고, Carol은 매칭된 캐릭터가 없으므로 c.job이 NULL이다.

따라서 둘 다 최종 결과에서 제외된다.

ON과 WHERE의 차이

구분역할

ON 두 테이블의 행을 어떻게 매칭할지 결정
WHERE JOIN 결과에서 어떤 행을 남길지 필터링

이 차이는 LEFT JOIN에서 특히 중요하다.

또한 유저 하나가 여러 캐릭터를 보유한다면 JOIN 결과는 유저 한 명당 여러 행이 나올 수 있다.

따라서 유저 수나 보상 합계를 계산할 때 JOIN 결과의 행 증가로 인해 중복 집계가 발생하지 않도록 주의해야 한다.

이번 복습에서는 처음에 조회 대상 유저를 불완전하게 답했지만, 최종적으로 ON과 WHERE의 차이를 구분할 수 있었다.


6. 서버 기반 지식 — HTTP 요청·응답과 인증 정책

HTTP는 클라이언트와 서버가 요청과 응답을 주고받기 위한 애플리케이션 계층 프로토콜이다.

게임 서버에서도 로그인, 인벤토리 조회, 구매 요청 등 다양한 기능에 HTTP API를 사용한다.

HTTP 요청의 구성

HTTP 요청에는 일반적으로 다음과 같은 정보가 포함된다.

  • Method: GET, POST 등의 요청 방식
  • URL 및 경로: 요청 대상 리소스
  • Header: 인증 정보나 콘텐츠 타입 등 부가 정보
  • Body: 요청에서 전달하는 데이터(필요한 경우)

서버는 요청을 받아 라우팅하고, 필요한 인증·인가 검사와 비즈니스 로직을 처리한 뒤 응답을 생성한다.

응답에는 상태 코드, 헤더, 필요한 경우 본문이 포함된다.

GET과 POST의 차이

GET은 주로 리소스 조회에 사용한다.

POST는 서버에 데이터 처리나 리소스 생성을 요청하는 데 사용한다.

그러나 HTTP Method 자체가 인증 여부를 결정하지는 않는다.

ASP.NET Core의 인증·인가 정책

다음과 같은 Minimal API를 생각해 보자.

app.MapGet("/game/notices", () =>
{
    return Results.Ok("공지사항");
}).AllowAnonymous();

app.MapGet("/player/inventory", () =>
{
    return Results.Ok("인벤토리 정보");
}).RequireAuthorization();

두 API 모두 GET 요청이지만 접근 정책은 다르다.

/game/notices는 AllowAnonymous()를 사용하므로 익명 사용자도 접근할 수 있다.

반면 /player/inventory에는 인가 정책이 적용된다. 기본 인가 정책에서는 인증된 사용자가 필요하다.

따라서 GET 요청이라고 무조건 인증해야 하는 것은 아니다.

인증과 인가의 차이

Authentication(인증) 은 요청한 사용자가 누구인지 확인하는 과정이다.

Authorization(인가) 은 해당 사용자에게 특정 리소스에 접근할 권한이 있는지 확인하는 과정이다.

예를 들어 로그인한 사용자는 인증되었더라도 다른 플레이어의 개인 인벤토리를 조회할 권한은 없을 수 있다.

HTTP 응답 실패와 DB 처리 결과는 다를 수 있다

게임 서버의 구매 API에서 특히 주의해야 하는 부분이다.

서버가 구매 트랜잭션을 COMMIT한 뒤 응답을 보내기 전에 연결이 종료될 수 있다.

이 경우 클라이언트는 응답을 받지 못했더라도 실제 DB의 구매 처리는 성공했을 수 있다.

따라서 클라이언트가 HTTP 요청에 실패했다는 사실만으로 구매가 실패했다고 판단해서는 안 된다.

구매 requestId와 저장된 처리 결과를 확인하는 멱등성 설계가 중요하다.

또한 HTTP 요청 본문이나 Query Parameter로 전달된 값은 클라이언트가 변경할 수 있으므로 서버에서 반드시 검증해야 한다.


오늘 새롭게 알게 된 점

  1. ConcurrentDictionary의 GetOrAdd는 valueFactory가 정확히 한 번 실행된다고 보장하지 않는다.
  2. TryAdd의 원자적 등록 성공과 외부 DB 보상의 원자성은 별개다.
  3. DP는 상태를 정의하고 이전 부분 문제의 결과를 재사용한다.
  4. 0/1 Knapsack에서 이전 보상 단계의 값을 참조해야 동일 보상의 중복 선택을 방지할 수 있다.
  5. Command 객체의 생성과 실제 명령 실행은 서로 다른 과정이다.
  6. 트랜잭션과 멱등성은 각각 원자성과 중복 요청 문제를 담당한다.
  7. TCP에서 ReadAsync가 0을 반환했다는 것은 메시지 완료가 아니라 스트림의 EOF를 의미한다.
  8. LEFT JOIN의 ON과 WHERE는 최종 조회 결과에 서로 다른 영향을 줄 수 있다.
  9. HTTP Method가 인증 여부를 결정하는 것은 아니다.

추가로 복습할 내용

  • GetOrAdd의 valueFactory 중복 실행과 TryAdd의 실제 활용
  • Struct 배열의 GC 관리와 복사 비용
  • DP의 C# 직접 구현과 1차원 공간 최적화
  • Greedy의 최적 부분 구조
  • Command 패턴의 실행 흐름과 구매 멱등성
  • TCP 부분 수신 및 EOF를 처리하는 C# 수신 루프
  • LEFT JOIN에서 ON·WHERE 조건과 NULL 처리
  • HTTP Authentication·Authorization 및 401·403 상태 코드

Day 12 학습을 마치며

이번 학습에서도 개념을 알고 있다고 생각했지만 실제 실행 결과를 예측하는 과정에서 오개념이 발견되었다.

특히 ConcurrentDictionary의 GetOrAdd, TCP의 EOF, Command의 역할은 설명을 다시 확인해야 했다.

반면 DP의 상태 정의와 점화식, LEFT JOIN의 조건식, HTTP의 인증 정책은 기억만으로 설명할 수 있었다.

앞으로도 각 기술이 정확히 어디까지 보장하는지, 실제 게임 서버에서는 무엇을 추가로 구현해야 하는지를 구분하는 능력을 키우려고 한다.


본문의 코드와 SQL은 학습용 예시다. 실제 컴파일, PostgreSQL 실행, 네트워크 테스트 또는 성능 측정 결과는 포함하지 않았다. 회사 비공개 소스 코드 및 고객 데이터는 사용하지 않았다.

Day 11 — 오늘 배운 게임 서버 개발 지식 5가지

학습·복습 기간: 2026년 11월 11일~13일
학습 주제: Struct와 Class, Greedy 알고리즘, Adapter 패턴, TCP 통신, PostgreSQL SQL 기초

게임 서버 개발 압축 학습 11일차에는 자료구조의 메모리 구조, Greedy 알고리즘, Adapter 패턴, 네트워크 통신, SQL 기초를 복습했다.

이번에 특히 중요했던 것은 코드가 어떤 결과를 내는지만 아는 것이 아니라, 그 결과가 발생하는 내부 원리를 이해하는 것이었다.

1. 자료구조 — Struct 배열과 Class 배열은 GC 부담이 어떻게 다를까?

C#에서 struct는 값 형식(Value Type), class는 참조 형식(Reference Type)이다.

다음 두 타입을 생각해 보자.

public struct MonsterStruct
{
    public int Hp;
    public int Attack;
}

public class MonsterClass
{
    public int Hp;
    public int Attack;
}

각 타입으로 10,000개의 요소를 가진 배열을 생성한다.

MonsterStruct[] structs = new MonsterStruct[10000];
MonsterClass[] classes = new MonsterClass[10000];

Struct 배열은 무엇을 저장할까?

MonsterStruct[]는 배열 객체 내부에 10,000개의 구조체 값을 직접 저장한다.

구조체의 Hp, Attack 필드는 배열 요소의 일부로 저장되므로, 개별 구조체를 위해 별도의 관리 객체를 생성하지 않는다.

중요한 점은 Struct라고 해서 무조건 Stack에 저장되는 것은 아니라는 사실이다.

배열 객체는 Managed Heap에 생성되므로, 배열 내부에 존재하는 구조체 값들도 힙에 위치한다.

따라서 Struct 배열 역시 GC의 관리 대상이다.

Class 배열은 무엇을 저장할까?

MonsterClass[]는 구조체 배열과 다르게 객체 참조를 저장할 공간을 가진다.

하지만 다음 코드만으로는 실제 MonsterClass 객체 10,000개가 생성되지 않는다.

MonsterClass[] classes = new MonsterClass[10000];

이 시점에는 배열 객체 한 개만 만들어지고 각 요소의 참조값은 null로 초기화된다.

실제 클래스 객체를 생성하려면 다음과 같은 작업이 필요하다.

for (int i = 0; i < classes.Length; i++)
{
    classes[i] = new MonsterClass();
}

이렇게 하면 배열 객체 1개와 MonsterClass 객체 10,000개를 합쳐 총 10,001개의 관리 객체가 생성된다.

둘 다 Managed Heap에 있는데 왜 GC 부담이 다를까?

이 부분을 처음에는 잘못 이해했다.

Class 배열에 참조값이 많기 때문에 GC 부담이 크다고 생각했지만, 중요한 것은 참조값 자체의 개수만이 아니다.

Struct 배열은 이 예시에서 관리 객체 한 개에 10,000개의 구조체 값을 포함한다.

반면 Class 객체를 각각 생성하면 관리 객체의 개수가 증가하고, 각 객체의 할당·추적·수명 관리에 추가 비용이 발생할 수 있다.

비교Struct 배열Class 배열 + 개별 인스턴스

배열 객체 1개 1개
별도 요소 객체 없음 10,000개
배열 요소의 내용 구조체 값 객체 참조
GC 관리 필요 필요
순차 접근 시 캐시 효율 유리할 가능성 높음 객체 배치에 따라 불리할 수 있음

Struct는 항상 빠를까?

그렇지는 않다.

Struct는 값 형식이므로 대입할 때 값이 복사된다.

구조체가 작으면 복사 비용이 낮을 수 있지만, 크기가 크고 복사가 자주 발생한다면 오히려 부담이 될 수 있다.

또한 실제 성능은 구조체 크기, 메모리 접근 방식, JIT 최적화 등에 따라 달라진다.

게임 서버에서 수많은 몬스터의 HP와 공격력을 매 틱 갱신한다면 작은 Struct 배열을 고려할 수 있다.

하지만 성능이 우수하다고 단정하지 않고 실제 벤치마크로 검증해야 한다.

2. 알고리즘 — Greedy가 항상 최적해를 찾지 못하는 이유

Greedy(탐욕 알고리즘)는 각 단계에서 정한 기준에 따라 현재 가장 유리한 선택을 하는 방식이다.

하지만 각 단계의 최선이 전체 문제의 최선과 반드시 일치하지는 않는다.

보상 선택 반례

보상 포인트가 10이고 다음 보상을 선택할 수 있다고 가정하자.

보상필요 포인트보상 가치

A 10 12
B 5 9
C 5 9

각 보상은 최대 한 번 선택할 수 있다.

보상 가치가 가장 큰 것부터 선택하는 Greedy 규칙을 사용하면 A를 선택한다.

A를 선택하면 포인트 10을 모두 사용하고 가치 12를 얻는다.

하지만 B와 C를 함께 선택하면 같은 포인트 10으로 가치 18을 얻는다.

따라서 이 문제에서는 개별 보상 가치가 가장 큰 항목을 먼저 선택하는 Greedy 규칙이 최적해를 보장하지 못한다.

탐욕적 선택 속성과 최적 부분 구조

Greedy의 최적성을 판단할 때는 두 가지 개념을 구별해야 한다.

탐욕적 선택 속성(Greedy-choice Property)

현재 단계의 탐욕적 선택을 포함하는 전체 최적해가 존재하는 성질이다.

최적 부분 구조(Optimal Substructure)

전체 문제의 최적해가 부분 문제의 최적해를 포함하는 성질이다.

처음에는 최적 부분 구조를 매 단계에서 가장 좋은 것을 선택하는 방식이라고 이해했다.

하지만 그것은 Greedy의 선택 방식에 가까운 설명이었다.

최적 부분 구조는 전체 최적해와 부분 최적해 사이의 관계를 말한다.

최단 경로로 이해하는 최적 부분 구조

다음 두 경로가 있다고 가정하자.

경로 1
A --2--> B --6--> G
총비용: 8

경로 2
A --2--> B --1--> C --3--> G
총비용: 6

B에서 G까지 직접 이동하는 비용은 6이지만, C를 경유하면 비용은 4다.

따라서 A → B → G는 최단 경로가 아니다.

A → B → C → G가 더 짧은 경로이고, 그 부분 경로인 B → C → G도 B에서 G까지의 최단 경로가 된다.

이렇게 전체 최적해가 부분 문제의 최적해를 포함하는 성질이 최적 부분 구조다.

단, 최적 부분 구조만 존재한다고 Greedy가 항상 최적해를 구하는 것은 아니다.

작업 선택 문제와 Greedy

서로 겹치지 않는 작업을 최대한 많이 선택하는 문제에서는 종료 시간이 빠른 작업을 우선 선택하는 Greedy 알고리즘을 사용할 수 있다.

종료 시간이 빠른 작업을 선택하면 이후 작업을 선택할 수 있는 여지를 최대한 남길 수 있기 때문이다.

하지만 어떤 Greedy 규칙이 최적해를 보장하는지는 문제에 맞는 근거가 필요하다.

이번 복습에서는 반례 계산은 정확했지만, 최적 부분 구조의 의미를 처음에 잘못 설명했다.

이후 추가 문제를 통해 개념을 수정했으므로 다음에는 힌트 없이 직접 설명할 수 있는지 확인할 예정이다.

3. 디자인 패턴 — Adapter로 외부 결제 SDK 연결하기

게임 서버에서는 Google Play, App Store, 외부 웹상점 등 다양한 결제 시스템과 연동할 수 있다.

문제는 각 외부 SDK가 제공하는 인터페이스와 응답 데이터 형식이 서로 다를 수 있다는 점이다.

Adapter 패턴의 역할

Adapter 패턴은 서로 호환되지 않는 인터페이스를 연결하는 패턴이다.

게임 서버에서 다음과 같은 공통 인터페이스를 사용한다고 가정하자.

public interface IPaymentVerifier
{
    Task<VerificationResult> VerifyAsync(
        string receipt);
}

그런데 외부 SDK는 다른 메서드를 제공한다.

CheckPurchaseAsync(receipt)

이 경우 Adapter가 서버와 외부 SDK 사이에서 변환 역할을 담당할 수 있다.

PurchaseService
      ↓
IPaymentVerifier.VerifyAsync()
      ↓
PaymentAdapter
      ↓
외부 SDK.CheckPurchaseAsync()
      ↓
외부 SDK 응답 수신
      ↓
서버용 VerificationResult로 변환
      ↓
PurchaseService에 반환

위 호출 구조는 개념 설명용이며, 실제 SDK의 정확한 API 계약을 나타내는 것은 아니다.

Adapter를 사용하는 이유

Adapter를 사용하면 PurchaseService가 외부 SDK의 구체적인 메서드나 반환 형식에 직접 의존하는 부분을 줄일 수 있다.

나중에 결제 SDK가 변경되더라도 Adapter 내부의 구현을 변경하는 방식으로 대응할 수 있다.

여기서 중요한 것은 Adapter가 단순히 여러 SDK를 하나의 함수로 합치는 패턴은 아니라는 점이다.

서로 다른 인터페이스와 데이터 형식을 서버가 사용하는 방식에 맞게 연결하는 것이 핵심이다.

Strategy·Decorator·Adapter 비교

패턴주요 목적

Strategy 실행할 동작이나 알고리즘 교체
Decorator 기존 객체를 감싸 부가 기능 확장
Adapter 서로 다른 인터페이스 연결

다만 단순한 SDK 호출 하나를 위해 항상 Adapter 클래스를 만들어야 하는 것은 아니다.

또한 Adapter 자체가 결제 검증의 신뢰성, 거래 중복 방지, 트랜잭션 정합성을 자동으로 보장하지는 않는다.

실제 결제 처리에서는 거래 ID 검증, 멱등성, 오류 처리 등을 별도로 구현해야 한다.

4. C# 게임 서버 — TCP, HTTP, WebSocket의 차이

게임 서버에서 통신 방식을 선택하려면 각 프로토콜의 특성을 이해해야 한다.

TCP는 메시지가 아니라 바이트 스트림이다

TCP는 신뢰성 있는 순서형 바이트 스트림을 제공하지만 애플리케이션 메시지의 경계를 보장하지 않는다.

예를 들어 클라이언트가 100바이트 메시지 하나를 보냈다고 가정하자.

서버의 ReadAsync()가 다음과 같이 데이터를 받을 수도 있다.

클라이언트 전송: 100 bytes

서버 첫 번째 ReadAsync: 40 bytes
서버 두 번째 ReadAsync: 60 bytes

따라서 ReadAsync() 한 번이 메시지 하나에 대응한다고 생각하면 안 된다.

반대로 여러 메시지의 바이트가 하나의 읽기 작업에서 함께 전달될 수도 있다.

Length-Prefix로 메시지 경계 구분하기

TCP에서 메시지를 구분하는 방법 중 하나가 Length-Prefix다.

메시지 앞에 본문 길이를 기록한 헤더를 붙여 전송한다.

예를 들어 프로토콜에서 헤더 크기를 4바이트로 정했다면 다음과 같다.

[4바이트 메시지 길이][메시지 본문]

서버는 다음 순서로 처리한다.

  1. 헤더 4바이트가 모두 수신될 때까지 읽는다.
  2. 헤더에서 본문 길이를 해석한다.
  3. 해당 길이만큼 본문을 모두 수신할 때까지 읽는다.
  4. 완전한 메시지가 준비되면 역직렬화하거나 명령을 처리한다.

여기서 중요한 사실은 헤더 4바이트조차 한 번의 ReadAsync로 모두 받을 수 있다는 보장이 없다는 점이다.

따라서 부분 수신을 처리하는 반복 로직이 필요하다.

또한 최대 패킷 크기를 검증하고 헤더의 바이트 순서를 송수신 측에서 일치시켜야 한다.

HTTP와 WebSocket은 언제 사용할까?

HTTP는 요청·응답 중심의 통신에 적합하다.

로그인, 계정 정보 조회, 결제 요청 등에서 활용할 수 있다.

WebSocket은 연결을 유지하면서 클라이언트와 서버가 양방향 메시지를 주고받는 데 적합하다.

실시간 채팅이나 상태 변경 알림 등에 사용할 수 있다.

실시간 전투처럼 지연에 민감한 상황에서는 UDP 기반의 프로토콜도 고려할 수 있다.

다만 UDP가 항상 TCP보다 빠르다는 뜻은 아니다. 유실·순서·재전송 등을 애플리케이션에서 어떻게 처리하는지도 함께 고려해야 한다.

5. 게임 서버 DB — WHERE, ORDER BY, LIMIT 복습

이번 DB 학습에서는 복잡한 트랜잭션보다 기본 SQL의 조건과 정렬을 다시 확인했다.

특히 NULL 검사와 AND·OR 조건식에서 오류가 있었기 때문에 복습이 필요했다.

NULL은 어떻게 검사할까?

다음과 같은 테이블이 있다고 가정하자.

user_idnicknamedeleted_at

1 Alice NULL
2 Bob 2026-11-10
3 Carol NULL
4 David 2026-11-12

deleted_at에 값이 존재하는 플레이어를 조회하려면 다음과 같이 작성한다.

SELECT user_id, nickname
FROM users
WHERE deleted_at IS NOT NULL;

결과는 Bob과 David다.

  • IS NULL: 값이 NULL인 행
  • IS NOT NULL: 값이 NULL이 아닌 행

일반적인 SQL에서는 NULL을 = NULL로 검사해서는 안 된다.

NULL은 알 수 없는 값이라는 의미이므로 비교 연산의 결과에 UNKNOWN이 발생할 수 있다.

AND와 OR의 우선순위

다음 SQL을 살펴보자.

SELECT nickname
FROM users
WHERE level >= 10
  AND gold >= 500
   OR gold < 100;

SQL에서 AND는 OR보다 우선순위가 높다.

따라서 이 조건은 다음과 같은 의미다.

WHERE (level >= 10 AND gold >= 500)
   OR gold < 100

예를 들어 Carol이 레벨 12, 골드 800이라면 첫 번째 조건을 만족한다.

Eve가 레벨 20, 골드 50이라면 두 번째 조건을 만족한다.

따라서 두 플레이어가 조회 대상이다.

실무에서는 복잡한 조건식을 괄호로 명확하게 표현하여 의도하지 않은 결과를 방지하는 것이 좋다.

ORDER BY와 LIMIT

골드가 가장 많은 플레이어 3명을 조회하려면 다음 SQL을 사용할 수 있다.

SELECT nickname, gold
FROM users
ORDER BY gold DESC
LIMIT 3;
  • ORDER BY gold: 골드 기준 정렬
  • DESC: 높은 값부터 낮은 값 순서
  • LIMIT 3: 최대 세 행 반환

복습에서 주어진 데이터의 결과는 다음과 같았다.

순위nicknamegold

1 Carol 800
2 Bob 700
3 Alice 200

이번에는 SQL 문법과 예상 결과를 모두 정확하게 작성할 수 있었다.

다만 실제 PostgreSQL에서 실행해 검증한 것은 아니다.


오늘 새롭게 알게 된 점

  1. Struct 배열도 Managed Heap에 생성되며 GC 대상이다.
  2. Class 배열에 참조 공간을 생성하는 것과 실제 Class 객체를 개별 생성하는 것은 다르다.
  3. GC 부담은 단순한 참조 개수가 아니라 관리 객체의 할당·수명·참조 관계 등을 함께 고려해야 한다.
  4. Greedy의 현재 최선 선택과 최적 부분 구조는 서로 다른 개념이다.
  5. Adapter는 외부 SDK 호출 및 응답 형식을 서버 인터페이스에 맞게 연결한다.
  6. TCP에서는 Length-Prefix 헤더도 부분 수신될 수 있다.
  7. PostgreSQL의 NULL 검사, AND·OR 우선순위, ORDER BY 정렬 기준을 정확히 구분해야 한다.

추가로 복습할 내용

  • Struct의 크기와 복사 비용
  • Struct 배열과 Class 배열의 실제 GC·성능 측정
  • Greedy의 탐욕적 선택 속성과 최적 부분 구조
  • 작업 선택 알고리즘의 C# 코드 및 시간 복잡도
  • Adapter의 외부 SDK 예외 처리
  • TCP의 Length-Prefix 부분 수신 처리
  • WebSocket 재접속과 UDP 패킷 유실 처리
  • PostgreSQL의 NULL 3값 논리와 복합 WHERE 조건

이번 학습에서는 자료구조와 SQL의 개념을 다시 설명할 수 있었지만, Greedy의 최적 부분 구조는 추가 설명이 필요했다.

앞으로는 잘못 이해한 개념을 다시 설명받는 데서 끝내지 않고, 일정 시간이 지난 후에도 힌트 없이 설명할 수 있는지 확인하려고 한다.


본문의 코드와 SQL은 학습 목적의 예시이며 별도의 컴파일·실행·성능 측정 결과는 포함하지 않았다. 게임 서버 사례는 가상의 상황이며 회사 내부 소스 코드나 고객 데이터는 포함하지 않았다.

+ Recent posts