This resume is also available in English.

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

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

逾時、重試與熔斷

Timeouts, Retries and Circuit Breakers

下游一定會變慢或失敗。這篇從期限預算談起,一步步實作指數退避加 jitter 的重試、只重試該重試的錯誤、重試預算,再用 Go 寫出三態熔斷器與艙壁隔離,讓訂單服務在下游出事時不被拖垮。

  • Go
  • Microservices
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:每個呼叫都要有期限
  3. 第 2 步:分辨哪些錯誤值得重試
  4. 第 3 步:指數退避加上 jitter
  5. 第 4 步:重試預算,避免重試放大
  6. 第 5 步:熔斷器的三種狀態
  7. 第 6 步:用 Go 實作一個熔斷器
  8. 第 7 步:艙壁隔離與降級
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈服務發現與負載平衡〉我們讓訂單服務找得到庫存與付款服務的每一個實例,並把請求平均分過去;這篇接著處理「找到了,但它很慢、或回錯誤」的時候該怎麼辦。

這篇要解決什麼

在 example.com/shop 裡,下單的流程是:api-gateway 把請求轉給 order,order 先呼叫 inventory 保留庫存,再呼叫 payment 扣款,最後把訂單狀態從 pending 改成 paid。單體時代這些都是函式呼叫,失敗了就是一個 error;拆成服務之後,每一次呼叫都多了網路、序列化、對方的連線池與垃圾回收,任何一環都可能讓呼叫變慢、卡住或失敗。

最危險的不是「失敗」,而是「慢」。一個直接回 503 的下游,呼叫端很快就知道結果;一個卡住三十秒才回的下游,會讓呼叫端的 goroutine、連線池、記憶體一起被佔住,請求越堆越多,最後整條鏈一起倒下,這就是所謂的連鎖失敗(cascading failure)。這篇要用四個工具把這件事擋下來:

工具解決的問題一句話
逾時(期限)卡住不回每個呼叫都要有上限,而且整條鏈共用一個截止時間
重試暫時性失敗只重試可能會成功的錯誤,並且退避、加隨機
熔斷下游持續失敗失敗太多就先不要打,給對方喘息,也讓自己快速失敗
艙壁一個下游拖垮全部不同下游各用各的資源池,互不搶用

這四個工具彼此相關:沒有逾時,重試永遠等不到「失敗」;沒有熔斷,重試會把已經生病的下游打得更慘;沒有艙壁,一個慢的付款服務會吃光呼叫庫存服務需要的資源。接下來一步一步把它們疊上去。

第 1 步:每個呼叫都要有期限

第一條規則很簡單:任何跨網路的呼叫都不能沒有上限。Go 的 http.Client 預設 Timeout 是零,代表永遠等;net.Dial 沒設定也可能等到作業系統層級的逾時,通常是好幾十秒甚至更久。實務上至少要在兩個地方設上限:

  • 用戶端整體:http.Client{Timeout: ...} 或 gRPC 的呼叫期限,防止任何一個請求無限期地掛著。
  • 每個請求:用 context.WithTimeout 或 context.WithDeadline 包住,讓上游的取消可以一路傳下來。

〈context:取消、逾時與資料傳遞〉已經介紹過 context 的基本用法,這裡要強調的是微服務特有的問題:逾時應該是「期限預算」,而不是每一跳各自的數字。

假設 api-gateway 對外承諾兩秒內回應。如果 order 呼叫 inventory 時自己又給一個兩秒的逾時,inventory 再呼叫資料庫時又給兩秒,那麼最壞的情況下,使用者早就在閘道收到逾時錯誤、甚至已經按了重新整理,後面的服務還在認真地做一件沒有人在等的事。這些「孤兒工作」佔用資源、還可能產生副作用(例如庫存已經保留了,但訂單已經被當成失敗)。

正確的做法是在入口設定一個截止時間,然後把同一個截止時間往下傳。gRPC 會自動把 context 的期限放進 grpc-timeout 標頭傳給下游;HTTP 沒有標準標頭,常見的做法是自訂一個標頭(例如帶剩餘毫秒數),在對方的中介層裡還原成 context.WithTimeout。用剩餘時間而不是絕對時間,可以避開兩台機器時鐘不同步的問題。

API Gateway 期限 = 現在 + 2.0s 訂單服務 收到時剩 1.9s 庫存服務:保留庫存 用掉 0.6s,回來時剩 1.2s 付款服務:扣款 用掉 0.5s,回來時剩 0.7s 每一跳都把「同一個截止時間」往下傳,而不是各自重新給一個逾時 保留庫存 0.6s 扣款 0.5s 剩 0.7s 給確認訂單 閘道 訂單 0s 2.0s 截止

圖:閘道設定兩秒的截止時間,訂單服務收到時只剩約 1.9 秒,保留庫存與扣款各自用掉一部分,最後剩下的才是確認訂單能用的時間(數字僅為示意)。

有了期限預算,每個服務都能做兩件聰明的事。第一,收到請求時先看剩多少時間,如果剩下的比自己最快的處理時間還少,直接回錯誤,不要開始做。第二,呼叫下游時可以再取更短的期限,例如「剩餘時間與 800ms 取小者」,這樣即使上游給了很寬的期限,單一下游也不會把預算全部吃掉,留一點給後面的步驟。

提示:期限只能變短不能變長。context.WithTimeout(parent, d) 產生的子 context,截止時間是「父的截止時間」與「現在加 d」兩者較早的那個,所以在下游呼叫時放心地取更短的期限,不會意外延長上游的承諾。

逾時的數字要怎麼定?一個常見的起點是參考下游的延遲分布:把逾時設在 p99 延遲的幾倍附近,而不是平均值的幾倍。設太短,下游只是偶爾慢一點就被當成失敗,失敗率上升,重試又把負載加大;設太長,就失去保護的意義。數字沒有標準答案,重點是要有依據,並且在〈可觀測性:日誌、指標、追蹤〉會談到的指標上持續觀察。

第 2 步:分辨哪些錯誤值得重試

有了期限,呼叫終於會「失敗」了,下一個問題是:失敗了要不要再試一次?很多人的第一個反應是全部重試三次,這通常是錯的。重試只有在兩個條件都成立時才有意義:

  1. 錯誤是暫時性的:再試一次有合理機會成功。
  2. 操作是冪等的:就算第一次其實成功了只是回應丟失,再做一次也不會造成重複的副作用。

第一個條件要靠錯誤分類。以 HTTP 與 gRPC 為例,大致可以這樣分:

類別HTTPgRPC要不要重試
下游暫時不可用503、連線被拒Unavailable要,退避後重試
被限流429ResourceExhausted要,但遵守 Retry-After
單次嘗試逾時用戶端逾時DeadlineExceeded視冪等性與剩餘預算
參數錯誤400、422InvalidArgument不要,結果永遠一樣
權限或認證401、403PermissionDenied不要
業務結果409、卡片被拒FailedPrecondition不要,這不是故障

第二個條件更容易被忽略。GET /orders/{id} 是天生冪等的,重試無害;但 POST /payments 如果第一次請求其實已經扣款成功,只是回應在網路上丟了,重試就會扣兩次錢。這種「不知道對方到底做了沒有」的情況在分散式系統裡是常態,不是例外。所以對有副作用的呼叫,要嘛不重試,要嘛先讓它變成冪等(帶冪等鍵),這正是下一篇〈冪等與分散式鎖〉的主題。

在 Go 裡,錯誤分類最好在用戶端轉接層(例如 internal/payment 的 client)就做好,用〈錯誤處理:包裝、哨兵、自訂型別〉介紹的哨兵錯誤或自訂型別表達,讓上層用 errors.Is 判斷,而不是到處比對狀態碼字串。

第 3 步:指數退避加上 jitter

決定要重試之後,下一個問題是「隔多久再試」。立刻重試幾乎沒有用:下游如果是因為過載而失敗,立刻重試只會讓它更過載。標準做法是指數退避(exponential backoff):第一次等 base,第二次等 2×base,第三次 4×base,並設一個上限,避免等待時間無限增長。

但只有指數退避還不夠。想像付款服務短暫故障一秒,在這一秒內有一千個請求失敗,它們全部在 100ms 後重試、300ms 後再重試……結果是每一波重試都在同一個瞬間湧進來,形成「驚群」,下游剛恢復又被打倒。解法是加上隨機抖動(jitter),讓每個用戶端的等待時間不一樣。

固定指數退避(沒有 jitter) 0 100ms 300ms 700ms 上千個客戶端在同一瞬間一起重試 (一根柱子 = 一大波請求) 指數退避 + full jitter 0 每次等待取 [0, min(上限, 基數×2ⁿ)) 的隨機值,重試被攤平在整段時間裡

圖:上方是固定指數退避,所有用戶端在同一刻重試;下方加上 full jitter,重試被攤平在整段時間裡,下游看到的是平滑的負載。

常見的 jitter 策略有幾種。Full jitter 是在 [0, min(上限, base×2ⁿ)) 之間取均勻隨機值,分散效果最好,也最簡單;equal jitter 是取一半固定、一半隨機,保證至少等一段時間;decorrelated jitter 則讓下一次的等待依賴上一次的隨機結果。對大多數服務來說,full jitter 已經足夠好。

下面這個程式把前三步組在一起:每次嘗試有自己的逾時、整體有期限預算、只重試暫時性錯誤、等待時間用 full jitter,而且在預算不夠再試一次時就提早放棄。

package main

import (
	"context"
	"errors"
	"fmt"
	"math/rand/v2"
	"time"
)

// 暫時性錯誤:重試可能會成功
var ErrUnavailable = errors.New("inventory: unavailable")

// 永久性錯誤:重試幾次結果都一樣
var ErrInvalid = errors.New("inventory: invalid sku")

type RetryPolicy struct {
	MaxAttempts int           // 含第一次,總共最多幾次
	Base        time.Duration // 第一次退避的上限
	Max         time.Duration // 退避上限的天花板
	PerTry      time.Duration // 每一次嘗試自己的逾時
}

func retryable(err error) bool {
	// 單次嘗試逾時(不是整體期限到了)也視為可重試
	return errors.Is(err, ErrUnavailable) || errors.Is(err, context.DeadlineExceeded)
}

// fullJitter 回傳 [0, min(Max, Base*2^attempt)) 之間的隨機等待時間
func fullJitter(p RetryPolicy, attempt int) time.Duration {
	ceil := p.Base << attempt
	if ceil <= 0 || ceil > p.Max {
		ceil = p.Max
	}
	return rand.N(ceil)
}

func Do(ctx context.Context, p RetryPolicy, op func(context.Context) error) error {
	var err error
	for attempt := 0; attempt < p.MaxAttempts; attempt++ {
		tryCtx, cancel := context.WithTimeout(ctx, p.PerTry)
		err = op(tryCtx)
		cancel()
		if err == nil {
			return nil
		}
		if ctx.Err() != nil {
			return fmt.Errorf("整體期限已到,放棄: %w", err)
		}
		if !retryable(err) || attempt == p.MaxAttempts-1 {
			return err
		}
		wait := fullJitter(p, attempt)
		// 剩下的預算連「等待+再試一次」都不夠,就不要浪費
		if dl, ok := ctx.Deadline(); ok && time.Until(dl) < wait+p.PerTry/2 {
			return fmt.Errorf("預算不足以再試一次: %w", err)
		}
		fmt.Printf("  第 %d 次失敗(%v),等 %v 後重試\n", attempt+1, err, wait.Round(time.Millisecond))
		t := time.NewTimer(wait)
		select {
		case <-ctx.Done():
			t.Stop()
			return fmt.Errorf("等待重試時期限已到: %w", err)
		case <-t.C:
		}
	}
	return err
}

func main() {
	p := RetryPolicy{MaxAttempts: 4, Base: 20 * time.Millisecond, Max: 200 * time.Millisecond, PerTry: 80 * time.Millisecond}

	// 情境一:庫存服務前兩次暫時不可用,第三次成功
	calls := 0
	reserve := func(ctx context.Context) error {
		calls++
		if calls <= 2 {
			return ErrUnavailable
		}
		return nil
	}
	ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
	err := Do(ctx, p, reserve)
	cancel()
	fmt.Printf("情境一:呼叫 %d 次,結果 err=%v\n", calls, err)

	// 情境二:參數錯誤,不應該重試
	calls = 0
	bad := func(ctx context.Context) error { calls++; return ErrInvalid }
	ctx, cancel = context.WithTimeout(context.Background(), 500*time.Millisecond)
	err = Do(ctx, p, bad)
	cancel()
	fmt.Printf("情境二:呼叫 %d 次,結果 err=%v\n", calls, err)

	// 情境三:每次都卡住到單次逾時,整體預算很快用完
	calls = 0
	slow := func(ctx context.Context) error {
		calls++
		<-ctx.Done()
		return ctx.Err()
	}
	ctx, cancel = context.WithTimeout(context.Background(), 200*time.Millisecond)
	err = Do(ctx, p, slow)
	cancel()
	fmt.Printf("情境三:呼叫 %d 次,結果 err=%v\n", calls, err)
}

執行後可以看到三種情境的差別(隨機等待時間每次不同):

  第 1 次失敗(inventory: unavailable),等 1ms 後重試
  第 2 次失敗(inventory: unavailable),等 21ms 後重試
情境一:呼叫 3 次,結果 err=<nil>
情境二:呼叫 1 次,結果 err=inventory: invalid sku
  第 1 次失敗(context deadline exceeded),等 15ms 後重試
情境三:呼叫 2 次,結果 err=預算不足以再試一次: context deadline exceeded

這段程式有幾個值得注意的細節。第一,ctx.Err() != nil 的檢查放在分類之前:如果是整體期限到了,不管錯誤長什麼樣子都不能再試。第二,context.DeadlineExceeded 被當成可重試,是因為它指的是「單次嘗試」的子 context 逾時,父 context 還有時間;這只適合冪等的操作。第三,等待用 select 同時監聽 ctx.Done(),上游取消時不會傻傻地睡完。第四,math/rand/v2 的 rand.N 可以直接對 time.Duration 取隨機值,而且全域來源是自動播種的,不需要自己處理種子。

第 4 步:重試預算,避免重試放大

即使每個呼叫都正確地退避,重試還有一個整體層面的問題:放大效應。假設呼叫鏈有三層,每層都重試三次,最下層在故障時會收到 3×3×3 = 27 倍的請求。下游明明已經不行了,重試卻讓它承受數十倍的負載,這是很多大型事故的共同模式。

處理放大效應有三個互補的原則:

  • 只在一層重試。通常選最靠近使用者的那一層,或最了解冪等性的那一層。其他層遇到失敗就把錯誤往上傳,不要自己再加一輪。
  • 限制重試次數。總嘗試次數兩到三次就夠了,再多通常只是在拖延失敗。
  • 使用重試預算(retry budget)。不只限制單一請求的重試次數,而是限制「重試佔總請求的比例」。例如規定重試請求不得超過正常請求的一成:平常偶爾失敗,重試幾乎都被允許;下游大規模故障時,重試配額很快用完,多出來的失敗直接回給上游,不會再加重負擔。

重試預算的實作可以很簡單:用一個 token bucket,每個成功的正常請求放進 0.1 個 token,每次重試要花掉 1 個 token,桶子空了就不重試。gRPC 的 retry policy 也有類似的 retryThrottling 設定(以 token 數與比例描述),用 gRPC 時優先使用框架提供的機制,不要自己再包一層重試。

提示:被限流(429 或 ResourceExhausted)時,如果對方有回 Retry-After,就照它說的時間等;這是下游明確告訴你它什麼時候有空,比任何退避公式都準。

第 5 步:熔斷器的三種狀態

重試處理的是「偶爾失敗」,但如果付款服務整個掛了五分鐘呢?這五分鐘內,每個下單請求都會乖乖地等逾時、重試、再等逾時,使用者等了好幾秒才收到失敗,訂單服務的 goroutine 與連線全部卡在等待上。更糟的是,下游恢復的那一刻,累積的請求一擁而上,可能又把它打倒。

熔斷器(circuit breaker)借用了電路保險絲的概念:偵測到下游持續失敗時,直接「跳開」,後續的呼叫不再送出,立刻回傳錯誤;過一段時間再放少量請求試探,確認恢復了才回到正常。它有三種狀態:

Closed 關閉 正常放行、計算失敗 Open 跳開 直接回 ErrOpen Half-open 半開 只放少量試探請求 連續失敗達門檻 等待 openTimeout 試探失敗 試探成功 成功或業務錯誤:失敗數歸零

圖:Closed 時正常放行並計算失敗;失敗達門檻跳到 Open,直接拒絕;等待一段時間後進入 Half-open,只放少量試探請求,成功就回 Closed,失敗就回 Open。

  • Closed(關閉):正常狀態,請求照常送出,同時統計失敗。失敗統計可以用「連續失敗次數」,也可以用「最近一段時間視窗內的失敗率」,後者對流量大的服務比較穩定,通常還會加上「視窗內至少要有 N 個請求才判斷」的條件,避免低流量時一兩次失敗就跳開。
  • Open(跳開):失敗超過門檻後進入。這段期間所有呼叫立刻回傳 ErrOpen,不碰網路。呼叫端因此能快速失敗,可以改走降級邏輯,例如回覆「付款系統忙碌中,訂單已保留,請稍後再付款」。
  • Half-open(半開):Open 維持一段時間後進入。只放行少量(常見是一個)試探請求;試探成功代表下游恢復,回到 Closed 並清除統計;試探失敗就回到 Open,重新計時。

熔斷器的關鍵設計問題是:什麼樣的錯誤算「失敗」?只有代表下游不健康的錯誤才該計入,例如逾時、連線失敗、5xx。卡片被拒、餘額不足、參數錯誤,都是下游正常運作下的業務結果,如果把它們算進去,一波刷卡被拒的請求就可能讓熔斷器跳開,把所有正常的付款也擋掉。

第 6 步:用 Go 實作一個熔斷器

社群有成熟的套件(例如 sony/gobreaker),實務上可以直接用。但自己寫一次能真正理解它的行為,而且核心只有幾十行。下面的實作採用連續失敗次數,Half-open 一次只放一個試探請求,並讓呼叫者決定哪些錯誤算失敗:

package main

import (
	"context"
	"errors"
	"fmt"
	"sync"
	"time"
)

type State int

const (
	Closed State = iota
	Open
	HalfOpen
)

func (s State) String() string {
	return [...]string{"closed", "open", "half-open"}[s]
}

var ErrOpen = errors.New("circuit breaker is open")

type Breaker struct {
	mu          sync.Mutex
	state       State
	failures    int           // closed 狀態下連續失敗次數
	threshold   int           // 連續失敗幾次就跳開
	openTimeout time.Duration // open 維持多久後放一個試探請求
	openedAt    time.Time
	probing     bool                 // half-open 時是否已有試探請求在跑
	isFailure   func(err error) bool // 哪些錯誤代表「下游不健康」
}

func NewBreaker(threshold int, openTimeout time.Duration, isFailure func(error) bool) *Breaker {
	return &Breaker{threshold: threshold, openTimeout: openTimeout, isFailure: isFailure}
}

func (b *Breaker) State() State {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.state
}

// allow 決定這次呼叫能不能放行
func (b *Breaker) allow() error {
	b.mu.Lock()
	defer b.mu.Unlock()
	switch b.state {
	case Open:
		if time.Since(b.openedAt) < b.openTimeout {
			return ErrOpen
		}
		b.state = HalfOpen
		b.probing = false
		fallthrough
	case HalfOpen:
		if b.probing {
			return ErrOpen // 一次只放一個試探請求
		}
		b.probing = true
	}
	return nil
}

func (b *Breaker) record(err error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	failed := err != nil && b.isFailure(err)
	switch b.state {
	case HalfOpen:
		b.probing = false
		if failed {
			b.trip()
		} else {
			b.state, b.failures = Closed, 0
		}
	case Closed:
		if !failed {
			b.failures = 0
			return
		}
		b.failures++
		if b.failures >= b.threshold {
			b.trip()
		}
	case Open:
		// 跳開前就已放行的慢請求,結果不影響狀態
	}
}

func (b *Breaker) trip() {
	b.state, b.openedAt, b.failures = Open, time.Now(), 0
}

func (b *Breaker) Call(ctx context.Context, fn func(context.Context) error) error {
	if err := b.allow(); err != nil {
		return err
	}
	err := fn(ctx)
	b.record(err)
	return err
}

var ErrPaymentDown = errors.New("payment: 503")
var ErrCardDeclined = errors.New("payment: card declined")

func main() {
	br := NewBreaker(3, 100*time.Millisecond, func(err error) bool {
		// 卡片被拒是業務結果,不代表付款服務壞掉
		return !errors.Is(err, ErrCardDeclined)
	})

	healthy := false
	charge := func(ctx context.Context) error {
		if !healthy {
			return ErrPaymentDown
		}
		return nil
	}
	ctx := context.Background()

	for i := 1; i <= 5; i++ {
		err := br.Call(ctx, charge)
		fmt.Printf("呼叫 %d:err=%v,狀態=%v\n", i, err, br.State())
	}

	fmt.Println("…等待 openTimeout,付款服務恢復…")
	time.Sleep(120 * time.Millisecond)
	healthy = true

	err := br.Call(ctx, charge)
	fmt.Printf("試探呼叫:err=%v,狀態=%v\n", err, br.State())

	err = br.Call(ctx, func(context.Context) error { return ErrCardDeclined })
	fmt.Printf("卡片被拒:err=%v,狀態=%v(不計入失敗)\n", err, br.State())
}

輸出如下,可以清楚看到狀態轉移:

呼叫 1:err=payment: 503,狀態=closed
呼叫 2:err=payment: 503,狀態=closed
呼叫 3:err=payment: 503,狀態=open
呼叫 4:err=circuit breaker is open,狀態=open
呼叫 5:err=circuit breaker is open,狀態=open
…等待 openTimeout,付款服務恢復…
試探呼叫:err=<nil>,狀態=closed
卡片被拒:err=payment: card declined,狀態=closed(不計入失敗)

幾個實作細節值得說明。第一,allow 與 record 分成兩次加鎖,呼叫本身不持有鎖,否則一個慢呼叫會讓所有 goroutine 排隊等鎖。第二,allow 裡從 Open 轉到 Half-open 用了 fallthrough,讓「時間到了的那一個請求」直接成為試探者。第三,record 在 Open 狀態下什麼都不做:熔斷器跳開前已經放行的慢請求,它們的結果不應該再改變狀態。第四,試探請求如果因為 panic 沒有呼叫到 record,probing 會一直是 true,熔斷器就永遠卡在 Half-open;正式環境的實作要用 defer 確保一定會記錄結果,或替試探加上逾時。

熔斷器要放在哪裡?一個呼叫端對每個下游(甚至每個下游的每個關鍵操作)各有一個熔斷器,而不是全服務共用一個。付款服務壞了,不應該連帶擋掉對庫存服務的呼叫。至於重試與熔斷的順序,通常是重試在外、熔斷器在內:讓每一次嘗試都經過熔斷器,熔斷器跳開時,重試迴圈收到 ErrOpen 就應該直接放棄,ErrOpen 不屬於可重試錯誤。

第 7 步:艙壁隔離與降級

最後一個工具來自造船:船艙用隔板分成好幾格,一格進水不會讓整艘船沉沒。艙壁(bulkhead)的意思是讓不同的下游使用不同的資源池,一個下游變慢時,只會耗盡它自己那一格的資源。

在 Go 裡,最常被耗盡的資源是「同時進行中的呼叫數」。goroutine 很便宜,但每個卡住的呼叫都佔著一條連線、一份記憶體、一個請求的生命週期。如果訂單服務對付款服務的呼叫沒有上限,付款服務一變慢,訂單服務的所有處理器 goroutine 都可能卡在等付款,連查訂單這種完全不需要付款的請求也受影響。用一個帶緩衝的 channel 當號誌,就能替每個下游設定獨立的並發上限:

// 片段:每個下游各自一個艙壁,滿了就立刻拒絕,不排隊
type Bulkhead struct{ slots chan struct{} }

func NewBulkhead(n int) *Bulkhead { return &Bulkhead{slots: make(chan struct{}, n)} }

var ErrBulkheadFull = errors.New("bulkhead full")

func (b *Bulkhead) Do(ctx context.Context, fn func(context.Context) error) error {
	select {
	case b.slots <- struct{}{}:
		defer func() { <-b.slots }()
		return fn(ctx)
	default:
		return ErrBulkheadFull // 也可以改成 select ctx.Done() 等一小段時間
	}
}

// 在 cmd/order/main.go 組裝時,付款與庫存各給一個
// payBH := NewBulkhead(50)
// invBH := NewBulkhead(100)

golang.org/x/sync/semaphore 提供了加權版本的號誌,概念相同。HTTP 層面還有另一個常被忽略的艙壁:http.Transport 的 MaxConnsPerHost。對不同下游使用不同的 http.Client(各自的 Transport),連線池就自然分開了,這也呼應〈database/sql、交易與連線池〉裡談過的連線池設定觀念。

當熔斷器跳開或艙壁滿了,呼叫端就需要降級(fallback)策略:

情境可能的降級
推薦服務失敗回傳熱門商品的快取清單
庫存查詢失敗商品頁顯示「庫存確認中」,下單時再嚴格檢查
付款服務失敗訂單維持 pending,提示使用者稍後付款
通知服務失敗放進訊息佇列稍後補發

降級的原則是:對核心交易保守,對周邊功能寬鬆。推薦清單舊一點沒關係,但付款失敗絕對不能假裝成功。付款的降級是「明確告訴使用者還沒付」,而不是「先當作付了」。

常見陷阱

  • 只設了用戶端逾時,沒傳期限:每一跳各自用固定逾時,上游放棄後下游還在做,產生孤兒工作與不一致的副作用。
  • 重試非冪等的操作:對扣款、建立訂單這類 POST 盲目重試,回應丟失時就會重複扣款。先有冪等鍵,再談重試。
  • 每一層都重試:三層各重試三次就是 27 倍放大。選一層重試,其他層把錯誤往上傳。
  • 退避沒有 jitter:所有用戶端在同一刻重試,下游一恢復就被同步的重試潮打倒。
  • 把業務錯誤算進熔斷:卡片被拒、參數錯誤不代表下游壞了,算進去會讓熔斷器誤跳,擋掉正常請求。
  • 全服務共用一個熔斷器:一個下游故障擋住所有下游。每個下游、必要時每個操作各自一個。
  • Half-open 放太多試探:剛恢復的服務被試探流量打倒,熔斷器在 Open 與 Half-open 之間來回震盪。
  • 逾時設得比下游的逾時還短:呼叫端已經放棄,下游卻還沒逾時,繼續佔用資源;外層的期限應該比內層長。
  • 在重試迴圈裡用 time.Sleep:上游取消時無法中斷,要用 select 同時等計時器與 ctx.Done()。
  • 忽略 Retry-After:被限流時還照自己的公式重試,等於無視下游的明確要求。

重點整理

  • 慢比失敗更危險;任何跨網路的呼叫都要有逾時,而且整條呼叫鏈共用一個期限預算,期限只會越傳越短。
  • 只重試「暫時性」而且「冪等」的操作;錯誤分類在用戶端轉接層做好,用 errors.Is 判斷。
  • 重試用指數退避加 full jitter,等待時要能被 context 取消,預算不夠時提早放棄。
  • 只在一層重試,並用重試預算限制重試比例,避免故障時的放大效應。
  • 熔斷器有 Closed、Open、Half-open 三態;只有代表下游不健康的錯誤才算失敗;每個下游各自一個。
  • 艙壁讓不同下游使用不同的資源池;搭配降級,對核心交易保守、對周邊功能寬鬆。
  • 這些機制的參數都需要指標佐證,失敗率、重試次數、熔斷狀態變化都應該被監控。

下一篇

重試讓暫時性失敗得以恢復,卻也帶來新的風險:回應丟失時重試扣款,使用者就可能被扣兩次錢。下一篇〈冪等與分散式鎖〉會用冪等鍵、唯一約束與 fencing token,讓「做兩次」的效果等於「做一次」。