Lamport Timestamp람포트 타임스탬프

각 노드는 단조 증가하는 카운터 L을 유지

규칙 1 (로컬 이벤트):
  이벤트 발생 시 L = L + 1

규칙 2 (메시지 전송):
  L = L + 1, 메시지에 현재 L 포함

규칙 3 (메시지 수신):
  L = max(자신의 L, 수신된 L) + 1

노드 A (L=0)         노드 B (L=0)         노드 C (L=0)

이벤트a1: L=1        이벤트b1: L=1
A→B 전송(L=1)        수신+처리: L=max(1,1)+1=2
                     이벤트b2: L=3
                     B→C 전송(L=3)        수신+처리: L=max(0,3)+1=4
이벤트a2: L=2                             이벤트c1: L=5

최종 타임스탬프: a1=1, b1=1, b2=3, c1=5, a2=2
전체 정렬: a1, b1, a2, b2, c1 (타임스탬프 순)

import threading

class LamportClock:
    def __init__(self):
        self.time = 0
        self.lock = threading.Lock()

    def tick(self) -> int:
        with self.lock:
            self.time += 1
            return self.time

    def send(self) -> int:
        return self.tick()

    def receive(self, received_time: int) -> int:
        with self.lock:
            self.time = max(self.time, received_time) + 1
            return self.time

# 분산 이벤트 로그
class DistributedEvent:
    def __init__(self, node_id: str, lamport_ts: int, data: dict):
        self.node_id = node_id
        self.lamport_ts = lamport_ts
        self.data = data

    def __lt__(self, other):
        if self.lamport_ts != other.lamport_ts:
            return self.lamport_ts < other.lamport_ts
        return self.node_id < other.node_id  # 타임스탬프 같을 때 노드 ID로 해결

람포트의 보장:
  a → b (a가 b에 인과) 이면 L(a) < L(b)  [참]
  역은 성립 안 함: L(a) < L(b) 이어도 a→b가 아닐 수 있음

예:
  L(a1)=1, L(b1)=1 → 동시 발생인지 인과인지 구분 불가!

벡터 클락: 동시성 정확히 탐지 가능
람포트 타임스탬프: 더 간단, 동시성 탐지 불필요한 경우 충분