Khóa Phân Tán (Distributed Locks) Trong Go — Toán Học Redlock, etcd & Chứng Phân Liệt Split-Brain

Điều kiện tiên quyết: Đây là Phần 6 của Khóa Học System Design. Bơi ngược lại Phần 5: Kafka & Bám Đuôi Sự Kiện để nhồi nhét mấy cái trò mồi rác sự kiện (event sourcing) trước khi xắn tay vào cùm gông khóa mõm.

Answer-first: Đám khóa phân tán (Distributed locks) được đẻ ra để giàn xếp cái nợ đòi độc chiếm cắn xé nhau (mutual exclusion problem) chéo qua vắt lại giữa 1 nùi server độc lập — trói gô lại (ensuring) bắt buộc chỉ chừa đúng nháy 1 thằng server thò mõm vào cắn cấu một bãi rác dùng chung (shared resource) tại 1 thời điểm. Cái bùa Redlock của nhà Redis quăng ra cái ổ khóa chạy bạt mạng đua xe (high-performance) xài chiêu trò kéo bè kéo cánh số đông (majority quorum) rải rác đè đầu mớ node master; Thằng etcd lại vỗ ngực xưng tên ban phát bùa hộ mệnh sống chết chắc nịch (stronger guarantees) nhờ cái giao ước máu Raft (Raft consensus) đổi lại phải nôn tiền trả giá bằng độ lề mề lê lết (higher latency).

Cớ Cớ Quái Gì Mọc Ra Căn Bệnh Đạp Giẫm Lên Nhau (Race Conditions) Giữa Chốn Tứ Tán Phân Tán?

Answer-first: Bệnh đạp giẫm chà đạp (Race conditions) bùng nổ văng miểng xuyên qua rào cản mớ server processes khi mà có một bầy server mạnh thằng nào thằng nấy xộc vào nghía (read) rồi lại cong chóp lên sửa (write) đè lên chung chóc 1 cái trạng thái (shared state) mà chẳng thèm vác loa báo cáo mâm nào mâm nấy (without coordination). Cục khóa mutex cùi bắp nội bộ 1 process (single-process) đem vứt xọt rác đi — cái ông cần là cái mỏ lết xích khóa (lock mechanism) toang hoác trình ình mà mọi ngóc ngách process đều phải lác mắt nhìn thấy (visible across all).

Mổ Bụng Căn Bệnh Giẫm Đạp Phân Tán (Anatomy of a Distributed Race Condition)

sequenceDiagram
    participant S1 as Server 1 (Bãi Pod A)
    participant S2 as Server 2 (Bãi Pod B)
    participant DB as Vựa Database

    S1->>DB: Ngó thử (Read) ví tiền balance=1000
    S2->>DB: Ngó ké (Read) ví tiền balance=1000
    Note over S1,S2: ❌ Cả 2 thằng cùng rúc đầu dòm thấy balance=1000 y chang

    S1->>DB: Bôi xóa (Write) balance=1000-500=500 (Thằng S1 móc túi withdrawal)
    S2->>DB: Bôi xóa (Write) balance=1000-300=700 (Thằng S2 vặt lông withdrawal)

    Note over DB: ❌ Kết quả chốt hạ balance=700, bốc cmn hơi văng mất hút $500 từ mẻ móc túi của S1 (lost $500)!

Thằng này mù mắt chẳng hề mảy may biết thằng kia đang thò tay làm trò mèo y chang (same transaction) ngay chóc cùng lúc (simultaneously). Cái mỏ lết phân tán (distributed lock) dộng gậy vả vỡ mồm cản vụ này (prevents this): Cấm tiệt, chỉ có đúng duy nhất 1 thằng xách chóp lọt vào lãnh địa chết (critical section) tại 1 thời khắc.

Tính Toán Vặn Ốc Redlock Safety Math — Cân Đo Đong Đếm Thời Gian Sống Sót (Validity Time)

Answer-first: Đồ chơi Redlock múa bút tính nhẩm cái mốc thời gian sống ngoi ngóp (validity_time) đặng chốt hạ xem cái cục khóa vừa giật được còn an toàn bám trụ xài tiếp hay không (still safe to use) — đè ngửa lôi cái hạn chót TTL đem trừ đi cái phần mồ hôi công sức thời gian lết xác đi giành giật (acquisition time) và nợ đồng hồ chạy láo (clock drift). Ngớ ngẩn tính ra âm mạng (negative) tức là ổ khóa lủng mẹ rồi bốc hơi cút xéo ngay lúc đang giành (expired during acquisition) nên phải ba chân bốn cẳng nhả ra tắp lự (released immediately).

Lời Nguyền Công Thức Redlock Validity Formula

$$\text{THỜI_GIAN_SỐNG_NGOI (MIN_VALIDITY)} = \text{TTL} - (\text{ĐổMồHôiĐiGiành (AcquisitionTime)} + \text{TrôiĐồngHồ (ClockDrift)} + \text{CọcBảoKêTrôi (DriftSafetyFactor)})$$

Mổ Ruột (Where):

• TTL: Hạn chót van xin (Requested lock duration) (Ví dụ 10,000 mili-giây).
• ĐổMồHôiĐiGiành (AcquisitionTime): Xương máu thời gian đứt ruột vác xác đi năn nỉ chốt khóa rải khắp tụi đông bầy (majority nodes).
• TrôiĐồngHồ (ClockDrift): Mớ phỏng đoán nhức nách về việc ván cờ NTP lệch sóng (skew) giữa bầy servers (~1–2ms/s → lết lết dãn nứt cỡ ~200ms cho mấy cái mâm xưởng chà bá).
• CọcBảoKêTrôi (DriftSafetyFactor): Tấm đệm hơi vớt vát (Safety buffer) = quăng bừa 1–2% của TTL.

Bài Toán Bốc Bát (Example calculation):

• TTL = 10,000ms
• AcquisitionTime = 120ms (3 thằng nodes × 40ms/mỗi thằng)
• ClockDrift = 50ms
• DriftSafetyFactor = 100ms (1% của số TTL)
• THỜI_GIAN_SỐNG_NGOI (MIN_VALIDITY) = 10,000 − (120 + 50 + 100) = 9,730ms ← Khóa sống phây phây bọc thép an toàn đét được 9.73 giây lận

Chiêu Thức Múa Võ Redlock (Redlock Algorithm) — Step by Step

graph TD
    Start([Khách chổng mông đòi khóa]) --> T1["Đóng đinh khắc ghi cột mốc T1"]
    T1 --> Acquire["Nhào vô vặt khóa trên đầu N cụ master Redis\n(Quăng lệnh SET key token NX PX ttl lẹ làng chớp nhoáng)"]
    Acquire --> Quorum{"Giật đủ bộ sậu đa số ≥ N/2+1 cụ master chưa?"}
    Quorum -->|Thọt (No)| Fail["Lột sạch nhả trả hết mớ khóa vớ vẩn vừa ăn cắp\n→ Chui rúc đợi vận hên bốc thăm lại (Retry after random delay)"]
    Quorum -->|Lụm (Yes)| Validity["Lôi bảng ra đếm MIN_VALIDITY = TTL - đổ mồ hôi (elapsed) - trôi đồng hồ (drift)"]
    Validity --> Valid{"Ngáp ngáp MIN_VALIDITY > 0 hông?"}
    Valid -->|Tạch (No)| Fail2["Khóa héo úa chết ngộp cmn giữa đường lúc đi giật\n→ Ói ra hết, làm ván mới (retry)"]
    Valid -->|Ngon (Yes)| Success["✅ Bỏ túi cái khóa sống thọ MIN_VALIDITY ms\nPhá cửa lao vô vùng cấm địa (Execute critical section)"]
    Success --> Release["Trả dồ (Release): Khè độc chiêu Lua script\n(soi kỹ token của ta chưa mới chịu DEL)"]

Rèn Gông Redlock Trói Chân Bằng go-redsync

Answer-first: Đồ nghề go-redsync/redsync là thánh thư mẫu mực trứ danh rèn Redlock ở cõi Go. Nó tự vác cuốc bao thầu cái trò lùa bầu bán đa số (majority quorum), lì đòn năn nỉ chập giật (retry with jitter), và mở còng cực kỳ bọc thép nhờ xài Lua script (prevents unlocking another client’s lock - chĩa mũi cản vụ lỡ tay vứt chìa khóa nhà thằng khác).

package lock

import (
    "context"
    "fmt"
    "time"

    "github.com/go-redsync/redsync/v4"
    "github.com/go-redsync/redsync/v4/redis/goredis/v9"
    goredislib "github.com/redis/go-redis/v9"
)

type DistributedLockManager struct {
    rs *redsync.Redsync
}

// NewDistributedLockManager đổ móng dựng Redlock giương súng vào đầu N cái mâm Redis master
// Ra chốn Production: bét nhất phải rinh 3 cụ master (N=3 → mới hót lụm được 2 mống làm quorum)
func NewDistributedLockManager(masterAddrs []string) *DistributedLockManager {
    var pools []redsync.Pool
    for _, addr := range masterAddrs {
        client := goredislib.NewClient(&goredislib.Options{
            Addr:         addr,
            DialTimeout:  50 * time.Millisecond,
            ReadTimeout:  50 * time.Millisecond,
            WriteTimeout: 50 * time.Millisecond,
        })
        pools = append(pools, goredis.NewPool(client))
    }
    return &DistributedLockManager{rs: redsync.New(pools...)}
}

// ExecuteWithLock trói tay (acquires) → phang búa thi hành (executes fn) → mở còng thả (releases)
func (dlm *DistributedLockManager) ExecuteWithLock(
    ctx context.Context,
    resourceName string,
    ttl time.Duration,
    fn func(ctx context.Context) error,
) error {
    mutex := dlm.rs.NewMutex(
        fmt.Sprintf("lock:%s", resourceName),
        redsync.WithExpiry(ttl),
        redsync.WithTries(5),
        redsync.WithRetryDelay(100*time.Millisecond),
    )

    if err := mutex.LockContext(ctx); err != nil {
        return fmt.Errorf("thọt méo chôm được còng phân tán cho thằng %q: %w", resourceName, err)
    }
    defer func() {
        // Mở còng (Unlock) bùa chú Lua script: chóc chỉ giáng búa DEL nếu như cái thứ moi ra trúng phóc là token đóng mác của nhà mình
        // Chặn họng cái trò ngu tháo còng nhầm cho thằng mả mẹ nào đó vô hốt tay trên (acquired by another) sau khi cái TTL của mình héo cmnr
        if ok, err := mutex.UnlockContext(ctx); !ok || err != nil {
            fmt.Printf("BÁO ĐỘNG (WARNING): banh chành vụ tháo còng %q: ok=%v err=%v\n", resourceName, ok, err)
        }
    }()

    return fn(ctx)
}

[!WARNING] Đạo luật mở còng an toàn (Safe unlock) là thứ sống còn chẳng được đàm phán. Đừng có mà vác cái búa DEL key ra đập vỡ còng trực diện. Nhỡ mà cái thẻ bài TTL khóa nhà mày tắt ngúm (e.g., mẻ dọn rác GC làm tình làm tội đứng sững lại) và có 1 thằng dở hơi khác nhảy vô thó được khóa, xài cú đấm thẳng DEL đồng nghĩa lột còng thả rông khóa của TỤI NÓ, chẳng phải khóa nhà mày đâu con. Câu thần chú bùa Lua if GET(key) == token_nhà_bố thì mới DEL(key) end cản sạch trò bóp nghẹt này. Thằng redsync đút sẵn trong quần lo hết mấy cái này rồi.

Bàn Cân Sống Chết Redis Redlock vs etcd — Decision Matrix

Answer-first: Món Redis Redlock rặt cái thói chơi hệ AP (AP-style) — phi thân xé gió tốc độ bàn thờ (~1–5ms), nhưng dính cái phốt đạp mìn rải rác ngáo ngơ ở mảng trôi đồng hồ (clock drift edge cases). Thằng etcd lại là đám cứng đầu bưng cái hệ CP (CP-style) cậy thế cái giao ước máu Raft (Raft consensus) — cày đường thẳng (linearizable), tự rặn bùa gia hạn hợp đồng (automatic lease renewal), mà bắt ngậm đắng nuốt cay với độ lề mề rề rà hơn (~5–20ms) cộng thêm cái phí nuôi báo cô nguyên 1 băng đảng etcd riêng biệt (dedicated etcd cluster).

Khóa Cầm Đồ Bấu Víu Hợp Đồng etcd Trong Go (etcd Lease-Based Lock)

package lock

import (
    "context"
    "fmt"
    "time"

    clientv3 "go.etcd.io/etcd/client/v3"
    "go.etcd.io/etcd/client/v3/concurrency"
)

type EtcdLockManager struct {
    client *clientv3.Client
}

func NewEtcdLockManager(endpoints []string) (*EtcdLockManager, error) {
    client, err := clientv3.New(clientv3.Config{
        Endpoints:   endpoints,
        DialTimeout: 5 * time.Second,
    })
    if err != nil {
        return nil, fmt.Errorf("ăn cám cắm vô etcd: %w", err)
    }
    return &EtcdLockManager{client: client}, nil
}

// ExecuteWithLock — Cái mỏ lết phân tán dựa hơi cắm sừng giấy tờ (lease-based) etcd
// Lỡ cái máy chạy lăn đùng ra chết (process crashes), tấm vé lease thăng thiên tự động vỡ nát → lột còng nhả khóa an toàn
func (e *EtcdLockManager) ExecuteWithLock(
    ctx context.Context,
    key string,
    ttl time.Duration,
    fn func(ctx context.Context) error,
) error {
    // Phiên chầu chực tự động bơm máu rặn vé lease thông qua bộ đệm KeepAlive goroutine
    session, err := concurrency.NewSession(e.client,
        concurrency.WithTTL(int(ttl.Seconds())),
        concurrency.WithContext(ctx),
    )
    if err != nil {
        return fmt.Errorf("thọt mẹ session etcd: %w", err)
    }
    defer session.Close()

    mutex := concurrency.NewMutex(session, fmt.Sprintf("/locks/%s", key))

    if err := mutex.Lock(ctx); err != nil {
        return fmt.Errorf("giật hụt khóa etcd: %w", err)
    }
    defer mutex.Unlock(ctx)

    return fn(ctx)
}

[!NOTE] Soi ruột cái mớ bòng bong MVCC etcd: etcd đút túi mớ chìa khóa (keys) thành ba cái nùi trói chùm mớ bong bóng lộn xộn (phiên_bản_chúa major_revision, phiên_bản_lắt_nhắt sub_revision, chuẩn_mã type) nhét kho BoltDB (xài rễ B+Tree). Mỗi đợt cầm búa đập vỡ ghi vào (write) là lòi rặn ra 1 cái số thứ tự revision hoàn toàn mới toanh — chẳng có trò bôi vẽ bậy bạ tại chỗ (no in-place modification). Cái mắt thần Watch API chực chờ rình mò nghe ngóng nhảy dựng theo revision, biến cái mớ vác tù và liên lạc (coordination) thành rập khuôn theo sự kiện giật dây mượt mà vứt xó 1 bên mấy trò đục khoét chọc gậy polling liên hoàn.

Múa Búa Phá Bùa Phân Liệt (Split-Brain) Với Ổ Khóa Phân Tán Kiểu Gì?

Answer-first: Chứng thần kinh phân liệt (Split-brain) bộc phát lên cơn điên khi mớ cáp mạng đứt gánh (network partition) giăng bẫy tống hai cụm servers lú lẫn đồng loạt vênh mặt đinh ninh lố lăng rằng (simultaneously believe) mỗi bên đang đút túi ôm cái khóa. Đồ nghề dẹp loạn bệnh lú (prevention mechanism) lạch cạch đấm nhau lóc chóc gắt gao giữa băng Redis và lò etcd.

Phe Vác Rựa Redis Redlock:

• Dí súng đòi khóa phải ăn nằm la liếm gật đầu đủ trên cái mâm đa số (majority - N/2 + 1) nodes — dăm ba nhóm tàn dư cỏn con (minority partition) chẳng có vé tạo sòng (form quorum).
• Ngặt Nỗi (But): Nhỡ cái mẻ hốt rác GC thọc gậy bánh xe làm chết đứng (GC pause) dai dẳng hơn cả cái bảng số hạn chót (lock TTL), thằng chủ nhân bưng khóa huyễn hoặc nhủ rằng mình đang giắt trong tay ổ khóa (believe it still has the lock) ngay chóc cái giây phút thằng khất cái lôm côm bốc mùi thứ hai hốt mợ đi nẫng tay trên mất xác (already acquired it). Trám bùa lỗ hổng bằng mấy cái biển cấm thẻ bài (fencing tokens) — rặn ra chuỗi số tăng đều bước vắt kiệt soi mói ở cửa tài nguyên (checked at the resource side).

Phe Xài Phép etcd (Raft):

• Pháp ấn Raft gào thét đinh ninh (guarantees) phán chỉ có duy nhất 1 thằng Chúa Tể (leader) trị vì. Thằng Chúa này phải chầu chực hóng hớt cho bằng hết đống vé gật (ACKs) hốt từ đông đảo bầy lũ tay sai (majority) rồi mới dám đóng gạch hạ bút (committing).
• Hễ ông Chúa bị nhốt chuồng cắt rốn lạc trôi (partitioned), ổng tự lết xác phế truất thoái vị (steps down) ngay sau chập chót đếm lùi quá giờ bầu chọn (election timeout).
• Dàn số thứ tự bốc vé cắm sừng lease của etcd lặc lè nhích thăng thiên tà tà (monotonically increasing) trên mặt trận toàn cầu — lôi mớ này ra rập khuôn bóp mồm tụi kia nhét làm thẻ bài fencing tokens luôn.

🔥 [Miếng Nghề Bãi Xịn Production Pattern]: PayPay hốt rác vác khóa canh cổng event mớ giật giải Ổ Bệnh (Problem): Bão săn mồi Flash campaign: thảy đại ¥500 đút lót vô họng đúng 10,000 khách sộp đầu bảng. Cả xưởng chà bá nhét một nùi máy chọc ngoáy chen lấn bóc đơn rần rần (concurrent requests). Đua Trâu (Race): Tay không tấc sắt cắm đầu lết vô: nguyên một cặp pod rình rập đồng loạt chọt mắt húp số đọc được count=9,999, ôm đầu húc tăng lên 1 → sổ nát khép dòng chễm chệ to chảng > 10,000. Trị Bệnh (Solution): Rinh mỏ lết Redlock khóa mõm gõ campaign:lucky-campaign-2024. Số TTL = 500ms hắt xì văng. Quả Ngọt (Result): Lẻ tẻ độc lai nháy 1 ông kẹ pod mon men nhảy vô khám điền thổ (check+increment) tại một phát. Con đếm đồng hồ điểm danh nhét thẳng bon chóc phóc nịt cứng ngắc đúng số 10,000. Giá Đánh Đổi (Trade-off): Vòi hít nhả rác write throughput bị xỏ gông kìm hãm thắt chóp ~2 đợt sờ/giây lọt mặt vô chốn (resource) khỉ ho cò gáy này. Nhịn nhục xơi được vì chốn này họa hoằn 3 đời trúng giải campaign lèo tèo lắm mới vác mỏ gõ kho (inventory writes are rare). (Mò hố từ: PayPay Tech Blog, 2022)

Hỏi Nhanh Đáp Gọn (FAQ)

Thời khắc vác dái chạy tới chốn nào rinh Redlock vs mâm etcd?

Túm áo Redlock hễ khi: tay lòi phèo dắt túi hốt cmn mâm Redis cluster sẵn ở đó rồi, mớ khóa lóc chóc tạch ngỏm đoản thọ (<30s), và gan cóc tía bao che phớt lờ cho lọt lưới 1 mớ ổ rác rủi ro lệch đồng hồ (clock drift edge case) bù thêm mớ bùa chú xức thuốc chống thẹo bù trừ (compensating mechanisms - chìa cản đúp idempotency key, thẻ bài xua tà fencing token). Đập bàn chọn etcd khi mà: sự an nguy sống chết (correctness is paramount) của nùi khóa đặt lên mâm tử thần (chốt số tính tiền nong financial settlement, kêu lính chăn DB database migration), ổ khóa dai nhách lê thê bám trụ dài kỳ, hoặc rảnh rang mướn osin tự châm xăng (automatic lease renewal) vác thẻ rước hạn (holder is slow) rùa bò.

Phân Liệt Mất Não (Split-brain) đẻ ở lỗ cống nào ra và vác chổi dập lụi kiểu gì?

Phân Liệt Mất Não (Split-brain) cắn phập nổi điên khi có tới tận hai băng đảng ổ chuột đồng loạt giương mắt ảo tưởng nung nấu lú lấp bám dính lấy y xì một cái ổ còng khóa phân tán — phốt này y như rằng thọt từ cú cắt cổ sập lưới mạng (network partition). Hầu Redis: rút roi nện vả bóp lủng mâm đa số quorum và nện thêm thẻ bài lọt hố fencing tokens. Trấn etcd: Bản hợp đồng máu Raft bóp cổ họng triệt đường sinh sản ngay tại gốc (prevents it by design) — chẳng chừa cửa ngoài mỗi ông Chúa tể (leader) vác loa oang oang chốt số, và lỡ mà vớ vẩn rớt cụng đầu cắt cáp chia rẽ ông Chúa đó cũng lủi thủi hạ cờ lùi tuốt (steps down automatically).

Môn Phái Ngón Đòn Mở Khóa An Toàn Đu Đỉnh Cho Dân Redlock Là Sao?

Bộ khẩu quyết chém lộn bùa Lua (The Lua script pattern):

if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

Phép này đóng khung thần thái nhảy vô rờ nắn ngắm kỹ nhòm xem (atomically checks if) cục giá trị đang bám dính cái ổ khóa có rập khuôn đúc 1 khuôn với cái vé bùa mác riêng (unique token) do thằng khách bấu víu hay không rồi mới đập DEL. chẳng có tấm màng xoa nắn cái bùa khỉ gió này (Without this check), rủi ro bay thẳng tay đập nhầm cái còng của thằng ranh con ất ơ khác mọc ra (after your TTL expired - sau đận TTL mày thăng thiên).

[!TIP] Khóa Lỗ (Locks) vs Cản Đúp (Idempotency) — cào bới xài chiêu nào ở đâu: Còng khóa phân tán chặn họng (prevent) cái trò cắm đầu chọt ngoáy lố lăng bu đông húc lộn (concurrent execution) vào vùng tử huyệt. Bùa cản đúp lộn xộn (Idempotency keys) rải lá chắn đạp bỏ ba cái đuôi di chứng ói mửa (duplicate side effects) hốt hụi bởi đám khách điếc lác cắm mặt đập cửa ăn mày retried requests. Chui rúc hố tính tiền (payment flows), ông nội MÓC CẢ CẶP (need both): ôm chặt khóa khóa mõm cho nhai nuốt trôi trơn 1 lệnh rút tiền sột soạt (one payment process runs at a time), rặn phọt thêm chìa khóa cản đúp chống chọi mớ giẻ rách lởm chởm đòi ăn vạ đập cửa lết lết timeout cũng chẳng làm hốc bay túi 2 phát gấp đôi tiền ngu (doesn’t double-charge). Bươi rác xem Phần 7: Chế Đồ API Cản Đúp (Idempotent API Design).

🔗 Bay Sang Bài Tới: Phần 7: Bùa Vẽ API Cản Đúp Trong Go (Idempotent API Design in Go) — Dán Tem Bùa Cản Đúp Idempotency Key, Khảm bùa Redis SetNX, Máy chép miệng HTTP response recorder, và miếng nghề sòng bài rạch mặt Stripe API.