분산 락 완전 가이드 2025: Redlock, Zookeeper, etcd, Fencing Token, 안전한 구현

lock = threading.Lock()

with lock:
    critical_section()

[Server A] ←─ network ─→ [Lock Service] ←─ network ─→ [Server B]

def acquire_lock(key, ttl=10):
    return redis.set(key, "locked", nx=True, ex=ttl)

def release_lock(key):
    redis.delete(key)

# 사용
if acquire_lock("my-resource"):
    try:
        do_work()
    finally:
        release_lock("my-resource")

# Client A가 락 획득
acquire_lock("my-resource")
# Client A가 작업 중...
# 작업이 30초 걸림 (TTL 10초 초과)
# 락 자동 만료

# Client B가 락 획득
acquire_lock("my-resource")

# Client A가 작업 끝나고 락 해제
release_lock("my-resource")
# → Client B의 락을 해제!

# Client C가 락 획득 가능
# Client B와 C가 동시에 작업!

import uuid

def acquire_lock(key, ttl=10):
    token = str(uuid.uuid4())
    if redis.set(key, token, nx=True, ex=ttl):
        return token
    return None

def release_lock(key, token):
    # Lua 스크립트로 원자성
    script = """
    if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('del', KEYS[1])
    else
        return 0
    end
    """
    redis.eval(script, 1, key, token)

[Redis] ← 죽으면 모든 락 잃음
   ↓
[Server A] [Server B] [Server C]

[Master Redis]
    ↓ async replication
[Slave Redis]

[Redis 1] [Redis 2] [Redis 3] [Redis 4] [Redis 5]
  ↓        ↓         ↓         ↓         ↓
[Client] → 모두에게 SET NX EX 시도
        → 3/5 이상 성공이면 락 획득

def acquire_redlock(key, ttl=10000):
    token = str(uuid.uuid4())
    quorum = len(redis_clients) // 2 + 1  # 3/5
    
    start_time = time.time() * 1000
    acquired = []
    
    for client in redis_clients:
        try:
            # 매우 짧은 timeout
            if client.set(key, token, nx=True, px=ttl):
                acquired.append(client)
        except:
            pass
    
    elapsed = time.time() * 1000 - start_time
    
    if len(acquired) >= quorum and elapsed < ttl:
        return token  # 락 획득 성공
    else:
        # 실패 - 모든 것 해제
        for client in acquired:
            release_lock(client, key, token)
        return None

1. Client A가 락 획득 (10초 TTL)
2. Client A가 GC로 15초 멈춤 (락 만료)
3. Client B가 락 획득
4. Client A가 깨어남 → 자기가 락 보유한다고 생각
5. Client A와 B가 동시에 작업

1. Client A가 락 획득 (10초 TTL)
2. Redis 시계가 갑자기 5초 점프 (NTP 동기화)
3. 락이 일찍 만료
4. Client B가 락 획득

1. Client A가 락 획득, 토큰 = 33
2. Client A가 GC로 멈춤
3. Client B가 락 획득, 토큰 = 34
4. Client B가 storage에 쓰기 (token 34)
5. Client A가 깨어남, storage에 쓰기 (token 33)
6. Storage가 33 < 34 확인 → 거부 ✅

def acquire_lock_with_token(key):
    token = redis.incr(f"{key}:token")  # 단조 증가
    if redis.set(key, token, nx=True, ex=10):
        return token
    return None

def write_to_storage(data, token):
    # Storage가 토큰 검증
    if storage.last_token >= token:
        raise StaleTokenError()
    storage.write(data)
    storage.last_token = token

def acquire_lock(zk, lock_path):
    # 1. 순차 ephemeral node 생성
    my_node = zk.create(
        f"{lock_path}/lock-",
        ephemeral=True,
        sequence=True
    )
    # 예: /lock/lock-0000000005
    
    while True:
        # 2. 모든 자식 노드 가져오기
        children = sorted(zk.get_children(lock_path))
        
        # 3. 내가 가장 작으면 락 획득
        if my_node.endswith(children[0]):
            return my_node
        
        # 4. 아니면 바로 앞 노드 watch
        my_index = children.index(my_node.split('/')[-1])
        prev_node = children[my_index - 1]
        
        zk.exists(f"{lock_path}/{prev_node}", watch=callback)
        wait_for_callback()

import org.apache.curator.framework.recipes.locks.InterProcessMutex;

InterProcessMutex lock = new InterProcessMutex(client, "/my-lock");
if (lock.acquire(10, TimeUnit.SECONDS)) {
    try {
        // 작업
    } finally {
        lock.release();
    }
}

import etcd3

client = etcd3.client()

# Lease 생성 (10초)
lease = client.lease(ttl=10)

# 락 획득
lock = client.lock("my-lock", ttl=10)
lock.acquire()

try:
    do_work()
finally:
    lock.release()

BEGIN;
SELECT * FROM accounts WHERE id = 123 FOR UPDATE;
-- 락 보유, 다른 트랜잭션은 대기
UPDATE accounts SET balance = balance - 100 WHERE id = 123;
COMMIT;
-- 락 해제

-- 락 획득
SELECT pg_advisory_lock(12345);

-- 작업
UPDATE ...;

-- 락 해제
SELECT pg_advisory_unlock(12345);

-- 1. 데이터와 버전 읽기
SELECT *, version FROM users WHERE id = 1;
-- version = 5

-- 2. 작업 후 업데이트
UPDATE users SET name = 'New', version = version + 1
WHERE id = 1 AND version = 5;
-- 영향 받은 행 = 0이면 실패 (다른 사람이 먼저 수정)

import threading

class RenewingLock:
    def __init__(self, key, ttl=10):
        self.key = key
        self.token = None
        self.ttl = ttl
        self.stop_renewal = False
    
    def acquire(self):
        self.token = acquire_lock(self.key, self.ttl)
        if self.token:
            self.renewal_thread = threading.Thread(target=self._renew)
            self.renewal_thread.start()
        return self.token
    
    def _renew(self):
        while not self.stop_renewal:
            time.sleep(self.ttl / 3)
            redis.expire(self.key, self.ttl)
    
    def release(self):
        self.stop_renewal = True
        release_lock(self.key, self.token)

import random

def acquire_with_retry(key, max_retries=10):
    for attempt in range(max_retries):
        if token := acquire_lock(key):
            return token
        # Exponential backoff + jitter
        delay = (2 ** attempt) * 0.1 + random.uniform(0, 0.5)
        time.sleep(delay)
    return None

class ReentrantLock:
    def __init__(self, key):
        self.key = key
        self.count = 0
        self.token = None
    
    def acquire(self):
        if self.count > 0:
            self.count += 1
            return True
        
        self.token = acquire_lock(self.key)
        if self.token:
            self.count = 1
            return True
        return False
    
    def release(self):
        self.count -= 1
        if self.count == 0:
            release_lock(self.key, self.token)
            self.token = None

# 잘못 - 데드락 가능
def transfer(from_id, to_id, amount):
    lock1 = acquire_lock(f"account:{from_id}")
    lock2 = acquire_lock(f"account:{to_id}")
    # ...

# 두 사용자가 동시에 서로에게 송금:
# A → B: lock A, lock B
# B → A: lock B, lock A
# → 데드락

# 올바름 - 정렬된 순서
def transfer(from_id, to_id, amount):
    first, second = sorted([from_id, to_id])
    lock1 = acquire_lock(f"account:{first}")
    lock2 = acquire_lock(f"account:{second}")
    # ...

[Job Queue]
    ↓
[Worker 1] (jobs A, B)
[Worker 2] (jobs C, D)
[Worker 3] (jobs E, F)

def process_payment(payment_id, amount):
    if db.exists(f"processed:{payment_id}"):
        return  # 이미 처리됨
    
    db.atomic_set(f"processed:{payment_id}", True)
    actually_charge(amount)

UPDATE inventory 
SET quantity = quantity - 1 
WHERE product_id = 123 AND quantity > 0;

events.append(OrderCreated(...))
events.append(InventoryReserved(...))
events.append(PaymentCharged(...))

class AccountActor extends Actor {
  var balance: BigDecimal = 0
  
  def receive = {
    case Deposit(amount) => balance += amount
    case Withdraw(amount) => balance -= amount
  }
}

분산 락이 정말 필요한가?
├─ 아니오 → 멱등성, CAS, 파티셔닝 사용
└─ 예
   ├─ 효율성 목적 (대략 OK)
   │  └─ Redis 단일 락 (단순)
   └─ 정확성 목적 (절대 안 됨)
      ├─ ZooKeeper / etcd
      └─ Fencing token (storage가 지원하면)