TCP vs UDP 판단 기준

TCP로 1바이트 데이터를 보내려면

1. 연결 수립: SYN → SYN-ACK → ACK        (3패킷, 1 RTT)
2. 데이터 전송: Data → ACK                 (2패킷)
3. 연결 종료: FIN → ACK → FIN → ACK        (4패킷, 2 RTT)

총 비용: 9패킷, 3+ RTT
순수 데이터: 1바이트

DNS 쿼리처럼 "50바이트 질문, 100바이트 응답"인 경우
TCP 오버헤드가 데이터보다 훨씬 크다!

게임 서버

UDP (실시간)
┌────────────┐
│ 위치 동기화│
│ 총알 궤적  │
│ 이펙트     │
│ 음성 채팅  │
└────────────┘
특성: 손실 허용, 낮은 지연 필요

TCP (중요 데이터)
┌────────────┐
│ 로그인     │
│ 아이템 거래│
│ 채팅       │
│ 매치 결과  │
└────────────┘
특성: 손실 불가, 순서 + 완전성 필수

                 신뢰성 요구
          낮음 ◄─────────────► 높음
         ┌─────────────┬─────────────┐
    높음 │  UDP        │  QUIC       │
         │ (게임,VoIP) │  (HTTP/3)   │
  지연   │             │             │
  민감도 ├─────────────┼─────────────┤
         │  UDP        │  TCP        │
    낮음 │  (DNS,IoT)  │ (HTTP,FTP)  │
         │             │  (이메일)   │
         └─────────────┴─────────────┘

TCP 스트림 (HTTP/2 멀티플렉싱)
  패킷: [A1][B1][A2][B2][A3][B3]
                    ↑
              A2 손실 (재전송 대기)

  수신 버퍼: [A1][  ][B1][B2][A3][B3]
                  ↑
            A2 도착 대기 중
            → B1, B2, A3, B3 모두 애플리케이션에 전달 못함!
            → 스트림 B는 A와 무관한데도 블로킹!

UDP 기반 (QUIC)
  스트림 A: [A1][  ][A3] → A2 재전송 대기는 A만 영향
  스트림 B: [B1][B2][B3] → 즉시 애플리케이션에 전달! ✓

import socket
import struct
import time
import threading

class ReliableUDP:
    """부분적 신뢰성을 가진 UDP 구현"""

    # 메시지 타입
    UNRELIABLE = 0   # ACK 불필요 (위치 업데이트 등)
    RELIABLE = 1     # ACK 필요 (아이템 획득 등)
    ACK = 2          # 확인 응답

    def __init__(self, port):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.sock.bind(("0.0.0.0", port))
        self.seq = 0
        self.pending_acks = {}    # seq → (data, addr, timestamp, retries)
        self.max_retries = 3
        self.retry_interval = 0.5  # 500ms

    def send_unreliable(self, data, addr):
        """신뢰성 불필요 메시지 (위치, 이펙트 등)"""
        # 헤더: [type(1B)][seq(4B)]
        packet = struct.pack("!BI", self.UNRELIABLE, self.seq) + data
        self.sock.sendto(packet, addr)
        self.seq += 1

    def send_reliable(self, data, addr):
        """신뢰성 필요 메시지 (아이템, 채팅 등)"""
        seq = self.seq
        packet = struct.pack("!BI", self.RELIABLE, seq) + data
        self.sock.sendto(packet, addr)
        self.pending_acks[seq] = (packet, addr, time.time(), 0)
        self.seq += 1
        return seq

    def send_ack(self, seq, addr):
        """ACK 전송"""
        packet = struct.pack("!BI", self.ACK, seq)
        self.sock.sendto(packet, addr)

    def check_retransmits(self):
        """재전송 확인 (타이머 스레드에서 호출)"""
        now = time.time()
        to_remove = []

        for seq, (packet, addr, timestamp, retries) in self.pending_acks.items():
            if now - timestamp > self.retry_interval:
                if retries >= self.max_retries:
                    print(f"[WARN] seq={seq} 전달 실패 (재시도 {retries}회)")
                    to_remove.append(seq)
                else:
                    self.sock.sendto(packet, addr)
                    self.pending_acks[seq] = (packet, addr, now, retries + 1)
                    print(f"[RETRY] seq={seq} 재전송 ({retries + 1}회)")

        for seq in to_remove:
            del self.pending_acks[seq]

    def receive(self):
        """메시지 수신 및 처리"""
        data, addr = self.sock.recvfrom(65535)
        msg_type, seq = struct.unpack("!BI", data[:5])
        payload = data[5:]

        if msg_type == self.ACK:
            if seq in self.pending_acks:
                del self.pending_acks[seq]
            return None, None, addr

        if msg_type == self.RELIABLE:
            self.send_ack(seq, addr)

        return msg_type, payload, addr

# 사용 예시:
# server = ReliableUDP(9000)
#
# 위치 업데이트 (손실 허용):
# server.send_unreliable(position_data, player_addr)
#
# 아이템 획득 (손실 불가):
# server.send_reliable(item_data, player_addr)