This resume is also available in English.

四、可靠性第 2 / 4 篇 · 全部目錄

專欄 › 四、可靠性 › 第 14 篇

冪等與分散式鎖

Idempotency and Distributed Locks

重試與至少一次投遞讓「同一件事被做兩次」成為常態。這篇用冪等鍵、唯一約束與去重表讓重複請求只生效一次,再拆解 Redis 分散式鎖、租約過期與 fencing token,說明為什麼光靠鎖保護不了付款。

  • Go
  • Microservices
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:先分清楚哪些操作天生冪等
  3. 第 2 步:用唯一約束擋住重複的業務資料
  4. 第 3 步:冪等鍵與請求去重表
  5. 第 4 步:用 Go 把冪等鍵跑一次
  6. 第 5 步:至少一次投遞讓冪等成為必需
  7. 第 6 步:分散式鎖與租約
  8. 第 7 步:為什麼光靠鎖保護不了付款:fencing token
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈逾時、重試與熔斷〉我們讓訂單服務在下游出狀況時懂得逾時、退避重試與快速失敗;這篇接著處理重試留下的副作用:當請求可能被送兩次,怎麼保證錢只扣一次。

這篇要解決什麼

分散式系統裡有一個很難接受、但必須接受的事實:呼叫端常常不知道對方到底做了沒有。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;

處理流程分成四種情況:

客戶端 Idempotency-Key 訂單服務 先插入冪等表再做事 idempotency_keys 主鍵 = 冪等鍵 插入成功 這是新請求 執行扣款、建單 把回應存回表裡 201 已存在:處理中 前一個請求還沒完 不能再做一次 請客戶端稍後再試 409 已存在:已完成 內容雜湊相同 不執行副作用 重播當時的回應 同一個 201 已存在:內容不同 同一把鍵 被拿去送別的內容 是客戶端的錯 422

圖:插入成功代表這是新請求,由這個請求負責執行;插入失敗就讀出既有紀錄,依狀態回 409、重播當時的回應,或在內容不符時回 422。

  1. 插入成功:這是第一次看到這把鍵,執行業務邏輯,完成後把狀態改成 done 並存下回應。
  2. 已存在且處理中:前一個帶同鍵的請求還在跑(使用者連點兩下),回 409,請呼叫端稍後重試。絕對不能再執行一次。
  3. 已存在且已完成:重播當時存下的回應,包括狀態碼與內容。呼叫端得到的結果和第一次完全一樣,這才是完整的冪等。
  4. 已存在但內容不同:同一把鍵被拿來送不同的請求,這是呼叫端的錯誤,回 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
餘額: -100

IdemStore.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 設定毫秒級的過期時間。這裡有三個缺一不可的細節:

  1. 一定要有過期時間(租約)。持有鎖的實例當機了,鎖不會自己消失;沒有過期時間,這個資源就永遠鎖死。
  2. 值要是隨機 token。解鎖時要確認「這把鎖還是我的」才能刪除,否則 A 的鎖過期後被 B 拿到,A 處理完再執行 DEL,就把 B 的鎖刪掉了。
  3. 檢查與刪除要原子化。「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 鎖服務 客戶端 B 取得鎖 GC 停頓/網路延遲 A 的租約(PX 10s) 過期 B 的租約 token 33 token 34 寫入 (34) 成功 醒來,寫入 (33) 儲存端:記住看過的最大 token = 34 33 ≤ 34 → 拒絕 A 的過期寫入

圖: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 把保證移到資源端;正確性攸關的操作,最後的防線是資料庫約束與冪等,而不是鎖。

下一篇

冪等讓重複的訊息不再可怕,但訂單、庫存與付款之間目前還是同步呼叫,任何一個服務慢下來,整個下單流程就跟著卡住。下一篇〈訊息佇列與事件驅動〉會把部分流程改成非同步事件,並談分區、消費者群組、重新投遞與死信佇列。