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

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

학습일: 2026년 11월 11일
복습일: 2026년 11월 12일
주제: C# 컬렉션 메모리, Prefix Sum, 디자인 패턴, 동시 구매 처리, PostgreSQL 기초

게임 서버 개발을 위한 압축 학습 10일차다.

오늘은 자료구조의 메모리 배치, 구간 합 알고리즘, 디자인 패턴, 동시 구매 처리, 관계형 데이터베이스를 공부했다.

특히 이번 복습에서는 개념을 이해했다고 생각했지만 실제 코드에 적용하면서 틀리는 부분이 있었다.

이번 학습에서 중요하게 느낀 것은 알고리즘의 시간 복잡도뿐 아니라 메모리 사용량, 데이터 정합성, 실제 구현 정확성까지 함께 고려해야 한다는 점이다.

1. 자료구조 — Struct와 Class의 메모리 구조

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

이 차이는 컬렉션에 데이터를 저장하는 방식과 실제 성능에도 영향을 줄 수 있다.

List<Struct>와 List<Class>의 차이

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

public struct PlayerStruct
{
    public int Level;
    public int Gold;
}

public class PlayerClass
{
    public int Level;
    public int Gold;
}

각 타입의 데이터를 List에 저장한다.

List<PlayerStruct> listA = new();
List<PlayerClass> listB = new();

두 List는 모두 내부적으로 배열을 사용하지만, 배열에 저장되는 데이터는 다르다.

List<PlayerStruct>

구조체가 값 형식이므로 내부 배열의 각 요소에 구조체 값 자체가 저장된다.

따라서 배열에 저장된 데이터를 순차적으로 접근할 때 연속적인 메모리 접근의 이점을 얻을 수 있다.

List<PlayerClass>

클래스는 참조 형식이므로 내부 배열에는 PlayerClass 객체 자체가 아니라 객체에 대한 참조가 저장된다.

실제 PlayerClass 객체들은 별도로 할당되므로 메모리에 연속적으로 위치한다는 보장이 없다.

CPU 캐시 지역성이 중요한 이유

CPU는 메모리에서 데이터를 읽을 때 인접한 데이터도 함께 캐시에 가져올 수 있다.

순차적으로 필요한 데이터가 인접해 있다면 캐시에 적재된 데이터를 활용할 가능성이 높아진다.

반면 객체 참조를 따라 여러 메모리 위치에 접근하면 캐시 효율이 불리할 수 있다.

따라서 전체 순회가 모두 O(N)이더라도 실제 실행 속도에는 차이가 발생할 수 있다.

하지만 struct가 항상 class보다 빠르다는 뜻은 아니다.

구조체가 크면 복사 비용이 증가할 수 있으며, 실제 접근 패턴과 객체 구성에 따라서도 성능이 달라진다.

게임 서버에서도 데이터의 크기, 변경 방식, 순회 빈도 등을 고려해 타입과 자료구조를 선택해야 한다.

2. 알고리즘 — Prefix Sum과 Sliding Window 비교

이번 복습에서 가장 많이 헷갈렸던 부분은 Prefix Sum과 Sliding Window의 선택 기준이었다.

두 알고리즘 모두 구간 합 계산에 활용할 수 있지만 적합한 상황이 다르다.

Prefix Sum이란?

Prefix Sum은 배열의 시작 위치부터 각 지점까지의 누적 합을 저장하는 방법이다.

예를 들어 다음 배열이 있다고 가정하자.

numbers = [2, 3, 1, 4]

맨 앞에 0을 추가하는 방식으로 Prefix Sum 배열을 만들면 다음과 같다.

prefix = [0, 2, 5, 6, 10]

이 배열을 사용하면 임의 구간의 합을 다음과 같이 계산할 수 있다.

구간 합 [left, right]
= prefix[right + 1] - prefix[left]

예를 들어 인덱스 1부터 3까지의 합은 다음과 같다.

prefix[4] - prefix[1]
= 10 - 2
= 8

Prefix Sum의 시간·공간 복잡도

작업복잡도

전처리 O(N)
구간 합 조회 O(1)
추가 공간 O(N)

데이터가 변경되지 않고 서로 다른 구간의 합을 여러 번 조회해야 한다면 적합하다.

Sliding Window와의 차이

Sliding Window는 연속된 구간을 이동하면서 기존 계산 결과를 재활용한다.

고정 길이 구간 합에서는 왼쪽에서 빠지는 값을 빼고 오른쪽에서 새로 들어오는 값을 더하면 된다.

예를 들어 연속된 100개 요소의 합 중 최댓값을 한 번 구한다면 고정 길이 Sliding Window를 사용할 수 있다.

구분Prefix Sum고정 길이 Sliding Window

적합한 상황 임의 구간 합 반복 조회 고정 길이 구간 계산
전체 처리 시간 전처리 O(N) O(N)
추가 공간 O(N) O(1)
핵심 원리 누적 합 저장 기존 구간 합 갱신

처음에는 이 두 알고리즘의 적용 상황을 반대로 선택했다.

하지만 다시 생각해 보니 차이가 명확해졌다.

Prefix Sum은 미리 계산하여 반복 조회를 빠르게 하고, Sliding Window는 구간을 이동하며 계산하는 방식이다.

RangeSum C# 구현에서 실수한 점

누적 합 배열을 이용해 구간 합을 조회하는 메서드를 작성하면서 다음 두 가지 실수가 있었다.

첫 번째는 C# 배열의 길이를 prefix.length라고 작성한 것이다.

C#에서는 Length의 첫 글자가 대문자여야 한다.

두 번째는 오른쪽 인덱스의 범위 조건을 잘못 계산한 것이다.

원본 배열의 길이가 N이라면, 맨 앞에 0을 추가한 Prefix Sum 배열의 길이는 N+1이다.

따라서 원본 배열의 마지막 유효 인덱스는 prefix.Length - 2다.

다음은 이러한 부분을 보완한 학습용 코드다.

static long RangeSum(
    long[] prefix,
    int left,
    int right)
{
    ArgumentNullException.ThrowIfNull(prefix);

    if (left < 0 || left >= prefix.Length - 1)
        throw new ArgumentOutOfRangeException(nameof(left));

    if (right < left || right >= prefix.Length - 1)
        throw new ArgumentOutOfRangeException(nameof(right));

    return prefix[right + 1] - prefix[left];
}

이 코드는 첫 요소가 0이고 길이가 N+1인 정상적인 누적 합 배열을 전달받는다는 전제다.

원본 배열이 비어 있다면 조회할 수 있는 구간이 없으므로 예외를 발생시킨다.

이번 복습에서는 구간 합 계산식과 경계 조건의 논리는 이해했지만, C#의 정확한 문법을 반복해서 틀렸다.

따라서 다음에는 전체 메서드를 다시 작성하고 컴파일까지 확인할 필요가 있다.

3. 디자인 패턴 — Observer와 Decorator의 적용 판단

디자인 패턴은 단순히 코드를 복잡하게 만드는 기술이 아니라, 반복되는 설계 문제를 해결하기 위한 방법이다.

오늘

+ Recent posts