冪等與分散式鎖
Idempotency and Distributed Locks
重試與至少一次投遞讓「同一件事被做兩次」成為常態。這篇用冪等鍵、唯一約束與去重表讓重複請求只生效一次,再拆解 Redis 分散式鎖、租約過期與 fencing token,說明為什麼光靠鎖保護不了付款。
這篇的步驟
上一篇〈逾時、重試與熔斷〉我們讓訂單服務在下游出狀況時懂得逾時、退避重試與快速失敗;這篇接著處理重試留下的副作用:當請求可能被送兩次,怎麼保證錢只扣一次。
這篇要解決什麼
分散式系統裡有一個很難接受、但必須接受的事實:呼叫端常常不知道對方到底做了沒有。order 呼叫 payment 扣款,等到逾時,可能的情況有三種:請求根本沒送到、請求送到了但還在處理、已經扣款成功但回應在路上丟了。從呼叫端看,這三種情況長得一模一樣。
上一篇說過,只有冪等的操作才能安全重試。但「不重試」也不是解法:使用者會自己按重新整理、手機網路會自動重送、閘道會重試、訊息佇列會重新投遞。換句話說,重複的請求一定會發生,問題只是我們有沒有準備好。
這篇的目標是讓「做兩次」的效果等於「做一次」,也就是冪等(idempotent)。我們會先用資料庫的唯一約束與冪等鍵處理 API 層的重複請求,再談另一個常被拿來防止重複的工具:分散式鎖。結論先說在前面:鎖可以減少並發衝突,但它本身不能保證正確性;真正的保證要來自儲存端的約束,例如唯一索引、條件更新與 fencing token。
| 機制 | 擋住什麼 | 保證強度 |
|---|---|---|
| 唯一約束 | 同一筆業務資料被建立兩次 | 強,由資料庫保證 |
| 冪等鍵+去重表 | 同一個 API 請求被執行兩次 | 強,前提是和業務寫入同一個交易 |
| 分散式鎖 | 多個實例同時做同一件事 | 弱,租約過期後可能有兩個持有者 |
| fencing token | 過期的鎖持有者寫入 | 強,前提是儲存端會檢查 |
第 1 步:先分清楚哪些操作天生冪等
冪等的定義是:同一個操作執行一次和執行多次,系統最後的狀態相同。注意是「狀態」相同,不是「回應」相同;第二次刪除同一筆資料可能回 404,但資料庫的狀態沒變,仍然是冪等的。
HTTP 規範裡 GET、PUT、DELETE 被定義為冪等,POST 不是。但這只是語意上的約定,實作才是關鍵。以訂單服務為例:
PUT /orders/{id}/status把狀態設成cancelled:設一次和設十次結果一樣,天生冪等。POST /orders/{id}/items加一件商品:每做一次就多一件,不冪等。UPDATE inventory SET stock = stock - 1:每做一次就少一件,不冪等。UPDATE inventory SET stock = 9 WHERE sku = 'book-1':設定成絕對值,冪等,但會蓋掉別人的並發更新。
把「相對操作」改寫成「絕對操作」是讓操作冪等的第一個技巧,但如上面最後一例,它常常和並發安全衝突。第二個技巧是讓每個操作有一個唯一身分,系統記住做過的身分,重複的就不再做。這個身分可以是業務上的自然鍵(例如一張訂單只能有一筆付款),也可以是呼叫端產生的冪等鍵。接下來的步驟都是在實作這個想法。
第 2 步:用唯一約束擋住重複的業務資料
最可靠的去重工具是資料庫的唯一約束,因為它在並發下也成立:兩個交易同時插入相同的鍵,資料庫保證只有一個成功。應用層的「先查有沒有,沒有再插入」在並發下是錯的,兩個請求可能同時查到「沒有」,然後都插入成功;這類問題在〈併發常見問題:從資料競爭到超賣〉會有更多例子。
以付款為例,業務規則是「一張訂單只會有一筆成功的扣款」,那就直接把它寫成約束:payments 表的 order_id 加上唯一索引。付款服務收到重複的扣款請求時,插入付款紀錄會因為唯一約束失敗,服務就知道這張訂單已經處理過,回傳既有的付款結果即可。
找業務上的自然鍵是最優先的做法,因為它不依賴呼叫端的配合。但不是每個操作都有自然鍵,例如「使用者建立一張新訂單」:同一個使用者可能真的想連續下兩張一樣的訂單,系統無法從內容判斷第二個請求是重複還是新的。這時就需要呼叫端告訴我們:這兩個請求是不是同一個意圖。
第 3 步:冪等鍵與請求去重表
冪等鍵(idempotency key)是呼叫端為每一個「操作意圖」產生的唯一值,通常是 UUID,放在 Idempotency-Key 標頭裡。重點在「意圖」:使用者按下一次「送出訂單」,前端產生一把鍵;不論這個請求因為網路被重送幾次,都帶同一把鍵。使用者真的想再下一張單,才會產生新的鍵。
伺服器端用一張去重表記錄看過的鍵:
-- 冪等鍵以「使用者 + 鍵」為範圍,避免不同使用者的鍵互相衝突
CREATE TABLE idempotency_keys (
user_id bigint NOT NULL,
key text NOT NULL,
request_hash text NOT NULL, -- 請求內容的雜湊,防止同鍵不同內容
status text NOT NULL DEFAULT 'processing', -- processing / done
response jsonb, -- 完成後的回應,重試時原樣重播
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, key)
);
-- 業務層的自然鍵:一張訂單只能有一筆付款
CREATE TABLE payments (
id bigserial PRIMARY KEY,
order_id text NOT NULL UNIQUE,
amount bigint NOT NULL, -- 以分為單位,和 Order.Total 一致
status text NOT NULL
);
-- 第一步永遠是「搶著插入」;影響 0 列代表這把鍵已經存在
INSERT INTO idempotency_keys (user_id, key, request_hash)
VALUES ($1, $2, $3)
ON CONFLICT (user_id, key) DO NOTHING;處理流程分成四種情況:
圖:插入成功代表這是新請求,由這個請求負責執行;插入失敗就讀出既有紀錄,依狀態回 409、重播當時的回應,或在內容不符時回 422。
- 插入成功:這是第一次看到這把鍵,執行業務邏輯,完成後把狀態改成
done並存下回應。 - 已存在且處理中:前一個帶同鍵的請求還在跑(使用者連點兩下),回 409,請呼叫端稍後重試。絕對不能再執行一次。
- 已存在且已完成:重播當時存下的回應,包括狀態碼與內容。呼叫端得到的結果和第一次完全一樣,這才是完整的冪等。
- 已存在但內容不同:同一把鍵被拿來送不同的請求,這是呼叫端的錯誤,回 422。少了這個檢查,一把重複使用的鍵會讓第二張訂單被默默當成第一張的重播。
最關鍵的設計是:業務寫入與冪等紀錄的狀態更新要在同一個資料庫交易裡。如果建立訂單成功了、但更新冪等紀錄之前程式當掉,下次重試會看到 processing 卡在那裡;反過來,如果先把冪等紀錄標成 done 再寫訂單,寫訂單失敗就會留下一個「已完成」卻沒有訂單的鍵。〈database/sql、交易與連線池〉介紹的交易寫法在這裡派上用場:同一個 *sql.Tx 裡建立訂單、更新冪等紀錄,一起提交。
當業務邏輯需要呼叫另一個服務(例如扣款)時,就無法和本地資料庫放在同一個交易裡了。這時要把冪等性往下傳:訂單服務呼叫付款服務時,也帶上一把冪等鍵(可以由訂單編號推導,例如 charge:{order_id}),讓付款服務自己去重。冪等是一路傳下去的性質,任何一層斷掉,重試就可能造成重複。
還有兩個實務細節。第一,處理失敗時要決定怎麼處理冪等紀錄:如果失敗沒有留下任何副作用(例如參數驗證失敗),可以刪除紀錄讓呼叫端用同一把鍵重試;如果可能留下副作用,就要存下失敗的回應,避免重試造成不一致。第二,processing 的紀錄要有逾時機制,否則程式崩潰會讓那把鍵永遠卡住;常見做法是記錄開始時間,超過一段時間後允許接手(接手時要能安全地重新執行或查詢下游的真實狀態)。冪等紀錄本身也要有保存期限,例如保留一天到一週後清除,期限要涵蓋呼叫端所有可能的重試時間。
第 4 步:用 Go 把冪等鍵跑一次
下面的程式用記憶體模擬去重表,示範五個帶同一把鍵的並發請求、一次稍後的重試,以及同鍵不同內容的情況;程式最後也預告了第 7 步會談的 fencing token:
package main
import (
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"sync"
"sync/atomic"
"time"
)
var (
ErrInProgress = errors.New("409:同一個冪等鍵的請求還在處理中")
ErrKeyReused = errors.New("422:冪等鍵被拿去送不同的內容")
ErrStaleFence = errors.New("拒絕:fencing token 過期")
)
// ---------- 冪等鍵:模擬資料庫裡的 idempotency_keys 表 ----------
type record struct {
reqHash string
done bool
response string
}
type IdemStore struct {
mu sync.Mutex
rows map[string]*record // 主鍵 = 冪等鍵,相當於 UNIQUE 約束
}
// Begin 嘗試「插入」一列;成功代表這個請求由我負責執行
func (s *IdemStore) Begin(key, reqHash string) (replay string, mine bool, err error) {
s.mu.Lock()
defer s.mu.Unlock()
r, ok := s.rows[key]
if !ok {
s.rows[key] = &record{reqHash: reqHash}
return "", true, nil
}
if r.reqHash != reqHash {
return "", false, ErrKeyReused
}
if !r.done {
return "", false, ErrInProgress
}
return r.response, false, nil
}
func (s *IdemStore) Finish(key, response string) {
s.mu.Lock()
defer s.mu.Unlock()
s.rows[key].done, s.rows[key].response = true, response
}
func hash(body string) string {
sum := sha256.Sum256([]byte(body))
return hex.EncodeToString(sum[:8])
}
var charges atomic.Int64 // 真正扣款的次數
func placeOrder(s *IdemStore, key, body string) (string, error) {
replay, mine, err := s.Begin(key, hash(body))
if err != nil {
return "", err
}
if !mine {
return replay + "(重播)", nil
}
charges.Add(1) // 副作用只會在這裡發生一次
time.Sleep(20 * time.Millisecond) // 模擬呼叫付款服務的耗時
resp := "201 訂單 A-1001 建立"
s.Finish(key, resp)
return resp, nil
}
// ---------- fencing token:模擬受保護的資源 ----------
type Ledger struct {
mu sync.Mutex
lastFence int64
balance int
}
func (l *Ledger) Write(fence int64, delta int) error {
l.mu.Lock()
defer l.mu.Unlock()
if fence <= l.lastFence {
return fmt.Errorf("%w:收到 %d,已看過 %d", ErrStaleFence, fence, l.lastFence)
}
l.lastFence = fence
l.balance += delta
return nil
}
func main() {
s := &IdemStore{rows: map[string]*record{}}
body := `{"sku":"book-1","qty":1}`
// 使用者連點五下,五個請求同時帶著同一把冪等鍵進來
var wg sync.WaitGroup
for i := range 5 {
wg.Add(1)
go func() {
defer wg.Done()
resp, err := placeOrder(s, "key-7f3a", body)
fmt.Printf("並發請求 %d:resp=%q err=%v\n", i, resp, err)
}()
}
wg.Wait()
resp, err := placeOrder(s, "key-7f3a", body)
fmt.Printf("稍後重試:resp=%q err=%v\n", resp, err)
_, err = placeOrder(s, "key-7f3a", `{"sku":"book-2","qty":9}`)
fmt.Printf("同鍵不同內容:err=%v\n", err)
fmt.Printf("實際扣款次數:%d\n", charges.Load())
// 客戶端 A 拿到 token 33 後卡住(例如 GC 停頓),租約過期,B 拿到 34
l := &Ledger{}
fmt.Println("B 寫入:", l.Write(34, -100))
fmt.Println("A 醒來後寫入:", l.Write(33, -100))
fmt.Println("餘額:", l.balance)
}輸出如下(並發請求的順序每次不同):
並發請求 3:resp="" err=409:同一個冪等鍵的請求還在處理中
並發請求 1:resp="" err=409:同一個冪等鍵的請求還在處理中
並發請求 2:resp="" err=409:同一個冪等鍵的請求還在處理中
並發請求 0:resp="" err=409:同一個冪等鍵的請求還在處理中
並發請求 4:resp="201 訂單 A-1001 建立" err=<nil>
稍後重試:resp="201 訂單 A-1001 建立(重播)" err=<nil>
同鍵不同內容:err=422:冪等鍵被拿去送不同的內容
實際扣款次數:1
B 寫入: <nil>
A 醒來後寫入: 拒絕:fencing token 過期:收到 33,已看過 34
餘額: -100IdemStore.Begin 裡的 map 加上 mutex,扮演的就是 INSERT ... ON CONFLICT DO NOTHING 的角色:檢查與插入是一個不可分割的動作。真實系統中這個保證來自資料庫的唯一約束,所以訂單服務即使跑了十個實例,也只有一個請求能插入成功。這是重點:冪等鍵的正確性來自共享儲存的原子操作,而不是應用程式記憶體裡的狀態。
第 5 步:至少一次投遞讓冪等成為必需
除了 API 重試,另一個重複的來源是訊息。下一篇〈訊息佇列與事件驅動〉會詳細介紹,這裡先建立一個觀念:訊息系統的投遞語意大致有三種。
| 語意 | 意思 | 代價 |
|---|---|---|
| 最多一次(at-most-once) | 可能丟,不會重複 | 先確認再處理,處理失敗就丟了 |
| 至少一次(at-least-once) | 不會丟,可能重複 | 處理完再確認,確認前當機就會重送 |
| 恰好一次(exactly-once) | 不丟不重複 | 跨系統時只能靠冪等「模擬」 |
大多數業務選擇至少一次,因為丟掉一筆付款事件比處理兩次更難補救。而「恰好一次」在跨越網路與多個系統時,本質上做不到:消費者處理完訊息、還沒確認就當機,訊息系統不可能知道處理到底完成了沒有。Kafka 的 exactly-once 語意指的是 Kafka 內部「讀取、處理、寫回 Kafka」這條封閉迴路;只要副作用落在 Kafka 之外(寫資料庫、呼叫付款閘道),就要回到應用層的冪等。
所以業界常說的「恰好一次」,更精確的說法是效果上只處理一次(effectively-once):投遞是至少一次,處理是冪等的,兩者相加,最終效果等同恰好一次。消費者實作冪等的方式和 API 一樣:用事件 ID 當去重鍵,在處理業務的同一個交易裡記錄「這個事件處理過了」。這張表常被稱為 inbox,在〈分散式交易:Saga 與 Outbox〉會再出現。
第 6 步:分散式鎖與租約
談完冪等,來看另一個常被用來「避免重複」的工具:分散式鎖。典型的需求是:訂單服務跑了好幾個實例,每天凌晨要執行一次對帳工作,只希望一個實例去做;或是同一張訂單的取消與付款回呼同時到達,希望它們排隊處理。
用 Redis 實作鎖的標準做法是 SET key token NX PX ttl:NX 表示只在鍵不存在時設定,PX 設定毫秒級的過期時間。這裡有三個缺一不可的細節:
- 一定要有過期時間(租約)。持有鎖的實例當機了,鎖不會自己消失;沒有過期時間,這個資源就永遠鎖死。
- 值要是隨機 token。解鎖時要確認「這把鎖還是我的」才能刪除,否則 A 的鎖過期後被 B 拿到,A 處理完再執行
DEL,就把 B 的鎖刪掉了。 - 檢查與刪除要原子化。「GET 比對 token,相同再 DEL」是兩個指令,中間可能被插隊,所以要用 Lua 腳本在 Redis 端一次完成。
// 片段:使用 github.com/redis/go-redis/v9
package lock
import (
"context"
"crypto/rand"
"encoding/hex"
"errors"
"time"
"github.com/redis/go-redis/v9"
)
var ErrNotAcquired = errors.New("lock: not acquired")
// 取得鎖的同時遞增 fencing 計數器;兩個 key 用同一個 hash tag,Redis Cluster 下才會落在同一個 slot
var acquireScript = redis.NewScript(`
if redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2]) then
return redis.call("INCR", KEYS[2])
end
return 0`)
// 只有 token 相符才刪除,避免刪到別人的鎖
var releaseScript = redis.NewScript(`
if redis.call("GET", KEYS[1]) == ARGV[1] then
return redis.call("DEL", KEYS[1])
end
return 0`)
type Lock struct {
rdb *redis.Client
key string
token string
Fence int64 // 交給受保護的資源檢查
}
func Acquire(ctx context.Context, rdb *redis.Client, name string, ttl time.Duration) (*Lock, error) {
b := make([]byte, 16)
if _, err := rand.Read(b); err != nil {
return nil, err
}
key := "{lock:" + name + "}"
token := hex.EncodeToString(b)
fence, err := acquireScript.Run(ctx, rdb, []string{key, key + ":fence"}, token, ttl.Milliseconds()).Int64()
if err != nil {
return nil, err
}
if fence == 0 {
return nil, ErrNotAcquired
}
return &Lock{rdb: rdb, key: key, token: token, Fence: fence}, nil
}
func (l *Lock) Release(ctx context.Context) error {
return releaseScript.Run(ctx, l.rdb, []string{l.key}, l.token).Err()
}這個實作在單一 Redis 節點上是正確的「盡力而為」鎖。但只要回頭看第一個細節就會發現問題:租約會過期,而持有者不一定知道自己的租約過期了。
第 7 步:為什麼光靠鎖保護不了付款:fencing token
想像這個情境:客戶端 A 拿到鎖,租約十秒。A 開始處理,卻遇到一次很長的停頓,可能是垃圾回收暫停、作業系統把程序換出記憶體、虛擬機被遷移,或只是網路封包延遲了很久。停頓期間租約到期,客戶端 B 拿到同一把鎖,開始處理並寫入。然後 A 醒來,它不知道自己睡了多久,以為還持有鎖,也寫入了。現在兩個「持有者」都寫了,鎖完全沒有發揮作用。
A 能不能在寫入前檢查一下鎖還在不在?沒有用:檢查和寫入之間永遠有空隙,停頓可以發生在任何一行程式碼之間。這是 Martin Kleppmann 在分析分散式鎖時提出的核心論點:在一個有程序停頓與網路延遲的系統裡,基於時間的租約無法單獨保證互斥。
他提出的解法是 fencing token:鎖服務每次發出鎖時,附帶一個單調遞增的數字。持有者寫入受保護的資源時必須帶上這個數字,而資源端記住看過的最大值,拒絕任何比它小(或相等)的 token。
圖:A 拿到 token 33 後停頓,租約過期,B 拿到 34 並寫入成功;A 醒來後用 33 寫入,儲存端因為已經看過 34 而拒絕。
注意保證的來源移動了:不再是「鎖保證只有一個人在寫」,而是「儲存端保證過期的人寫不進來」。在資料庫裡,這只需要一個條件更新:
-- 受保護的資源自己記住最大的 fencing token
ALTER TABLE inventory_reservations ADD COLUMN last_fence bigint NOT NULL DEFAULT 0;
UPDATE inventory_reservations
SET quantity = $2,
last_fence = $3
WHERE order_id = $1
AND last_fence < $3; -- 影響 0 列 → token 過期,這次寫入被拒絕這也解釋了標題的問題。以付款為例,鎖只能「減少」兩個實例同時扣款的機率;當鎖因為租約過期而失效時,真正擋住重複扣款的是付款服務的冪等鍵與 payments.order_id 的唯一約束。外部的付款閘道不會幫你檢查 fencing token,所以對外部扣款,冪等鍵是唯一可靠的防線。
關於 Redis 還有兩個要知道的限制。第一,主從架構使用非同步複寫,主節點拿到鎖後還沒複寫就當機,從節點升級後鎖就不見了,另一個客戶端可以再次取得;fencing 計數器也可能因此倒退,所以要求嚴格的場合,計數器應該來自具線性一致性的來源,例如資料庫序列或 etcd 的 revision。第二,Redis 官方提出的 Redlock 演算法用多個獨立節點投票來降低這個風險,但 Kleppmann 指出它依賴「時鐘漂移有上限、停頓有上限」的假設,而且沒有提供 fencing token,因此不適合用在正確性攸關的場合。Redis 的作者對此有不同看法,這場討論值得一讀;實務上的共識大致是:
- 為了效率(避免重複做同一件昂貴但無害的工作,例如重建快取):單節點 Redis 鎖就夠了,偶爾失效只是浪費一點資源。
- 為了正確性(重複執行會造成錯誤,例如扣款、扣庫存):不要只依賴鎖,要用資料庫約束、條件更新、fencing token,或使用 etcd、ZooKeeper 這類基於共識的協調服務,並讓資源端參與檢查。
常見陷阱
- 先查再插入:應用層「查不到才建立」在並發下會兩個都建立,去重一定要靠唯一約束或原子操作。
- 冪等鍵只存在記憶體或本機快取:多實例部署時,重試打到另一台就失效了。去重狀態要放在所有實例共享的儲存。
- 業務寫入與冪等紀錄不在同一個交易:當機時留下「做了但沒記」或「記了但沒做」的不一致狀態。
- 沒有比對請求內容:同一把鍵送不同內容時默默重播舊回應,第二筆操作就這樣消失了。
- 冪等只做一層:訂單服務去重了,但呼叫付款服務時沒有傳冪等鍵,重試時付款服務仍然會重複扣款。
- 鎖沒有過期時間,或用固定值當 token:前者會在持有者當機時永遠鎖死,後者會讓 A 誤刪 B 的鎖。
- 以為檢查一下鎖還在就安全:檢查與寫入之間的停頓無法避免,要讓資源端用 fencing token 拒絕過期寫入。
- 把 Redis 鎖用在正確性攸關的地方:非同步複寫與租約過期都會讓鎖失效;付款、庫存要靠資料庫約束與冪等。
- 把「恰好一次」當成訊息系統會替你做的事:跨系統的副作用只能靠冪等消費做到效果上的恰好一次。
重點整理
- 重複請求一定會發生;目標是讓「做兩次」的效果等於「做一次」。
- 優先使用業務自然鍵加唯一約束;沒有自然鍵時,由呼叫端產生冪等鍵代表一次操作意圖。
- 去重表要記錄請求雜湊、狀態與回應;處理中回 409,已完成重播回應,內容不符回 422。
- 業務寫入與冪等紀錄放在同一個交易;跨服務時把冪等鍵一路往下傳。
- 至少一次投遞加上冪等處理,才是實務上的「恰好一次」。
- Redis 鎖要用
SET NX PX、隨機 token 與 Lua 原子解鎖;但租約可能在持有者不知情時過期。 - fencing token 把保證移到資源端;正確性攸關的操作,最後的防線是資料庫約束與冪等,而不是鎖。
下一篇
冪等讓重複的訊息不再可怕,但訂單、庫存與付款之間目前還是同步呼叫,任何一個服務慢下來,整個下單流程就跟著卡住。下一篇〈訊息佇列與事件驅動〉會把部分流程改成非同步事件,並談分區、消費者群組、重新投遞與死信佇列。