併發常見問題:從資料競爭到超賣
Concurrency Pitfalls: From Data Races to Overselling
把一路上最常踩到的併發問題整理成十個:從 Go 程式裡的資料競爭、goroutine 洩漏與死結,到資料庫的遺失更新、超賣、熱點列、快取雪崩與重複處理訊息,每個都講症狀、原因、偵測方法與修法。
這篇的步驟
上一篇〈從單體到微服務:十萬、百萬、千萬級的架構怎麼演進〉看完了系統怎麼隨著規模長大,api-gateway、order、payment、inventory 四個服務也已經在叢集裡跑起來了。系統能動、規模變大之後,真正的考驗才開始:流量一大、副本一多、重試一多,許多在本機測試從來沒出現過的問題就會冒出來。這一部分「實戰踩坑」回頭整理一路上最常遇到的問題,這篇先談併發,下一篇談支付。
這篇要解決什麼
併發問題有一個共同的特徵:在開發環境幾乎不會發生,在正式環境卻一定會發生。開發時只有你一個人在點,請求一個接一個進來;上線後同一秒有幾百個請求同時讀寫同一份資料,任何「先讀、再判斷、再寫回」的程式碼都有機會被別人插隊。更麻煩的是,這類錯誤通常不會讓程式當掉,而是安靜地算錯:計數少了一點、庫存變成負數、同一則訊息被處理兩次,等到使用者或對帳發現時,往往已經過了好幾天。
這篇把常見的併發問題分成兩層來看。前半是 Go 程式裡 的問題:資料競爭、map 併發寫入、迴圈變數被閉包捕獲、goroutine 洩漏、死結、無上限地開 goroutine。後半是 資料庫與跨服務 的問題:遺失更新與超賣、熱點列、快取雪崩、訊息重複處理。這兩層的本質其實一樣,都是「多個執行者同時對同一份狀態做讀改寫」,只是共享的東西從記憶體裡的變數,換成了資料庫的一列、快取裡的一個 key,或訊息佇列裡的一則訊息。
每個問題都照同一個順序講:症狀(你會看到什麼)、為什麼(背後的機制)、怎麼重現或偵測(怎麼確定就是它),最後是怎麼修。修法如果在前面的文章教過,這裡只點出重點並附上連結,不再重講一次。
第 1 個問題:資料競爭(data race)
症狀
計數器、統計數字或快取裡的值偶爾不對,而且每次跑的結果都不一樣;有時候是結構裡的兩個欄位彼此矛盾,例如訂單的 Status 已經是 paid,但 PaidAt 還是零值。最難受的是,加了一行 log 想觀察,問題就不見了。
為什麼
Go 的記憶體模型規定:當兩個 goroutine 同時存取同一個變數,其中至少一個是寫入,而且兩者之間沒有任何同步(mutex、channel、sync/atomic、WaitGroup 等建立的「先發生於」關係),這就是資料競爭,程式的行為就沒有保證。最常見的例子是 n++:它看起來是一行,實際上是「讀出 n、加一、寫回」三個步驟。兩個 goroutine 同時讀到 5、各自加一、各自寫回 6,結果加了兩次只變成 6,其中一次的更新被覆蓋掉了。
圖:兩個 goroutine 都先讀到 5,再各自寫回 6,其中一次加一就這樣消失了。
除了「少算」以外,資料競爭還可能讓編譯器與 CPU 的重新排序被你看見:另一個 goroutine 可能先看到 Status 改了、後看到 PaidAt 改了,甚至對多個字組組成的值(字串、slice、interface)讀到寫了一半的結果。所以資料競爭不能用「反正只是統計數字,差一點沒關係」來合理化。
怎麼重現或偵測
Go 內建的競爭偵測器是最有效的工具:go test -race、go run -race 或 go build -race。它會在執行時記錄每一次記憶體存取,只要實際跑到兩個沒有同步的存取,就印出兩邊的呼叫堆疊。下面這個測試檔同時放了有問題的版本與兩種修法:
package counter
import (
"sync"
"sync/atomic"
"testing"
)
// 有資料競爭的版本:n++ 是「讀、加一、寫回」三步
func countUnsafe(workers, times int) int {
n := 0
var wg sync.WaitGroup
for range workers {
wg.Add(1)
go func() {
defer wg.Done()
for range times {
n++
}
}()
}
wg.Wait()
return n
}
// 修法一:用 sync.Mutex 保護整段讀改寫
func countMutex(workers, times int) int {
var (
mu sync.Mutex
n int
wg sync.WaitGroup
)
for range workers {
wg.Add(1)
go func() {
defer wg.Done()
for range times {
mu.Lock()
n++
mu.Unlock()
}
}()
}
wg.Wait()
return n
}
// 修法二:單一數值用 atomic 就夠了
func countAtomic(workers, times int) int64 {
var n atomic.Int64
var wg sync.WaitGroup
for range workers {
wg.Add(1)
go func() {
defer wg.Done()
for range times {
n.Add(1)
}
}()
}
wg.Wait()
return n.Load()
}
func TestCountUnsafe(t *testing.T) {
if got := countUnsafe(8, 1000); got != 8000 {
t.Errorf("countUnsafe = %d, want 8000", got)
}
}
func TestCountSafe(t *testing.T) {
if got := countMutex(8, 1000); got != 8000 {
t.Errorf("countMutex = %d, want 8000", got)
}
if got := countAtomic(8, 1000); got != 8000 {
t.Errorf("countAtomic = %d, want 8000", got)
}
}用 -race 跑,會看到類似這樣的輸出(已縮短):
$ go test -race ./...
==================
WARNING: DATA RACE
Read at 0x00c0000122b8 by goroutine 14:
example.com/shop/internal/counter.countUnsafe.func1()
.../counter_test.go:18 +0x94
Previous write at 0x00c0000122b8 by goroutine 9:
example.com/shop/internal/counter.countUnsafe.func1()
.../counter_test.go:18 +0xa4
Goroutine 14 (running) created at:
example.com/shop/internal/counter.countUnsafe()
.../counter_test.go:15 +0x74
==================
--- FAIL: TestCountUnsafe (0.00s)
counter_test.go:67: countUnsafe = 7590, want 8000
testing.go:1867: race detected during execution of test
FAIL報告的讀法是:「第 18 行的讀取」與「第 18 行先前的寫入」發生在兩個不同的 goroutine,而這兩個 goroutine 都是在第 15 行建立的。順著堆疊就能找到共享的變數。
提示:競爭偵測器只抓得到實際執行到的競爭,沒有誤報,但會漏報。所以測試要真的製造併發(開多個 goroutine、用
t.Parallel()),並把go test -race ./...放進 CI。它會讓程式慢上數倍、記憶體用量也明顯增加,一般不在正式環境常態開啟,但可以在壓測環境跑一份-race的建置。
怎麼修
原則只有一句:共享的可變狀態,要嘛只讓一個 goroutine 擁有,要嘛每次存取都經過同步。可以把狀態交給單一 goroutine,其他人透過 channel 傳訊息給它(〈Goroutine、Channel 與並發模式〉講過的做法);或是用 sync.Mutex 包住整段讀改寫。
至於 atomic 和 mutex 怎麼選:只有一個數值、操作本身就是一個原子動作(加一、讀取、比較後交換)時,用 sync/atomic 的型別(atomic.Int64、atomic.Bool、atomic.Pointer[T])最簡單也最快。一旦牽涉到多個欄位要一起保持一致,或是「先檢查、再決定、再寫入」,就該用 mutex。一個常見的錯誤是把每個欄位都換成 atomic,以為這樣就安全了:每個欄位單獨讀寫確實不會競爭,但 if a.Load() > 0 { b.Store(...) } 這種組合依然可能被別人插隊,這叫做邏輯上的競爭條件(race condition),競爭偵測器抓不到,只能靠設計避免。
第 2 個問題:map 併發寫入讓程式直接結束
症狀
服務偶爾整個重啟,日誌最後一行是 fatal error: concurrent map writes 或 fatal error: concurrent map read and map write,後面接著一大串 goroutine 堆疊。在 Kubernetes 上看到的是 Pod 的重啟次數一直增加。
為什麼
Go 內建的 map 不支援併發讀寫。執行時期在 map 的操作裡有一個「正在寫入」的旗標,偵測到另一個 goroutine 同時在寫或讀時,就直接以 fatal error 結束整個行程。它刻意設計成無法用 recover 攔下來,因為 map 的內部結構可能已經損壞,繼續跑只會產生更難查的錯誤。常見的觸發點是把 map 當成全域快取,例如在 order 服務裡用 map[string]Product 暫存商品資料,請求處理函式一邊讀、背景更新一邊寫。
怎麼重現或偵測
這個偵測是盡力而為,不一定每次都觸發,但只要寫一個測試同時開幾個 goroutine 讀寫同一個 map,用 -race 跑一定抓得到。另一個線索是 fatal error 印出來的堆疊:它會列出當下所有 goroutine,搜尋 mapassign 或 mapaccess 就能找到互相衝突的兩個位置。
怎麼修
最直接的做法是用 sync.RWMutex 包住 map,讀取用 RLock、寫入用 Lock。sync.Map 只適合兩種情況:key 寫入一次之後大多只讀,或是不同 goroutine 各自操作不相交的 key;其他情況它不一定比 RWMutex 快,而且失去了型別檢查。寫入量非常大時,可以把資料依 key 雜湊分成多個分片,每片各自一把鎖,減少大家搶同一把鎖的機會。還有一種常被忽略的做法是整份替換:背景定期建出一份全新的 map,再用 atomic.Pointer[map[string]Product] 一次換上去,讀取端完全不需要鎖,前提是建好之後不再修改它。
第 3 個問題:迴圈變數被閉包捕獲
症狀
在迴圈裡為每筆訂單開一個 goroutine 去寄通知,結果有些訂單收到好幾封、有些一封都沒有;或是把每個元素的位址存進 slice,最後發現全部指向同一個值。
為什麼
在 Go 1.22 以前,for i, v := range items 的 i 和 v 在整個迴圈只有一個變數,每一輪只是把新的值寫進去。閉包捕獲的是變數本身而不是當下的值,所以 goroutine 真正開始執行時,讀到的常常已經是後面幾輪、甚至最後一輪的值;同時主迴圈在寫、goroutine 在讀,這本身也是資料競爭。
Go 1.22 改變了語意:每一輪迭代都會建立新的變數,三段式的 for i := 0; i < n; i++ 也一樣。這個改變只在模組的 go.mod 宣告 go 1.22 以上時生效,所以舊專案升級工具鏈但沒改 go 這一行,行為不會變。要注意的是,這個改變只解決「迴圈變數被共用」,不會解決閉包裡寫入外層共享變數造成的競爭,例如在 goroutine 裡 results = append(results, x) 依然需要同步。
怎麼重現或偵測
go vet 內建的 loopclosure 檢查會在舊語意下對「在迴圈最後一行用 go 或 defer 捕獲迴圈變數」發出警告;-race 也會抓到主迴圈寫入與 goroutine 讀取之間的競爭。檢查 go.mod 的 go 版本是第一步,因為它決定了你的程式碼到底是哪一種語意。
怎麼修
新專案把 go.mod 設在 1.22 以上即可。必須支援舊版本時,有兩種寫法:在迴圈內加一行 v := v 建立新的變數,或把值當作參數傳進 goroutine:go func(v Item) { ... }(v)。即使在新語意下,把需要的值明確當參數傳入仍然是好習慣,讀程式的人不用去想這段到底依賴哪一版的規則。
第 4 個問題:goroutine 洩漏
症狀
服務剛部署時一切正常,跑了幾天之後記憶體慢慢上升,最後被 Kubernetes 以 OOMKilled 砍掉重啟;監控上 go_goroutines 這個指標只升不降。重啟後又恢復正常,於是問題被當成「偶發」而一直沒有處理。
為什麼
goroutine 不會被垃圾回收。只要它卡在一個永遠不會完成的動作上,例如往沒有人接收的 channel 送值、從永遠不會關閉的 channel 讀值、等待一個沒有逾時的網路呼叫,它就會一直佔著堆疊和它參考到的所有物件。最典型的寫法是「開一個 goroutine 去呼叫下游,主流程用 select 等結果或逾時」:逾時之後主流程走了,背景的 goroutine 做完事想把結果送回 channel,卻再也沒有人接收。
package main
import (
"context"
"errors"
"fmt"
"runtime"
"time"
)
// 模擬呼叫庫存服務,耗時不固定
func callInventory() int {
time.Sleep(200 * time.Millisecond)
return 42
}
// 會洩漏的版本:逾時返回後,沒有人再接收 ch,
// 背景 goroutine 卡在 ch <- 永遠結束不了。
func stockLeaky(timeout time.Duration) (int, error) {
ch := make(chan int)
go func() { ch <- callInventory() }()
select {
case n := <-ch:
return n, nil
case <-time.After(timeout):
return 0, errors.New("timeout")
}
}
// 修好的版本:緩衝 1 讓送出永不阻塞,並用 context 傳遞取消。
func stockFixed(ctx context.Context) (int, error) {
ch := make(chan int, 1)
go func() { ch <- callInventory() }()
select {
case n := <-ch:
return n, nil
case <-ctx.Done():
return 0, ctx.Err()
}
}
func main() {
before := runtime.NumGoroutine()
for range 100 {
_, _ = stockLeaky(10 * time.Millisecond)
}
time.Sleep(300 * time.Millisecond) // 等背景工作都做完
fmt.Println("leaky: 多出的 goroutine =", runtime.NumGoroutine()-before)
before = runtime.NumGoroutine()
for range 100 {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
_, _ = stockFixed(ctx)
cancel()
}
time.Sleep(300 * time.Millisecond)
fmt.Println("fixed: 多出的 goroutine =", runtime.NumGoroutine()-before)
}用 go run -race . 執行,輸出是 leaky: 多出的 goroutine = 100 與 fixed: 多出的 goroutine = 0:每一次逾時都留下一個卡住的 goroutine,請求量一大就是成千上萬個。其他常見的洩漏來源還有:忘記呼叫 context.WithCancel 回傳的 cancel、time.Ticker 沒有 Stop、讀取 HTTP 回應後沒有關閉 Body、消費者迴圈只等 channel 卻沒有監聽 ctx.Done()。
怎麼重現或偵測
正式環境最有用的是 goroutine profile。服務開啟 net/http/pprof 後(〈效能調校:pprof 與 benchmark〉介紹過,記得只在內部埠開放),用 go tool pprof http://localhost:6060/debug/pprof/goroutine 看哪一個函式上卡了最多 goroutine,或直接打開 /debug/pprof/goroutine?debug=1,它會把相同堆疊的 goroutine 合併計數。洩漏的特徵非常明顯:某一行 chan send 或 select 前面掛著幾千個、而且隨時間增加。隔一段時間抓兩次比對,增加的那一組就是兇手。
在測試裡,可以借用 goleak 的概念:測試結束時檢查還有沒有不該存在的 goroutine。開源的 goleak 函式庫就是做這件事,只用標準函式庫的話,也可以像上面的程式一樣比較 runtime.NumGoroutine() 的前後差值,給背景工作一點收尾時間後再斷言。
怎麼修
每開一個 goroutine 前都先回答一個問題:它什麼時候、因為什麼而結束? 實務上的規則是:會阻塞的地方都要能被 context 取消(〈context:取消、逾時與資料傳遞〉);只送一次結果的 channel 給緩衝 1,讓送出的一方永遠不會卡住;cancel 一律緊接著 defer cancel();長期執行的背景迴圈要在〈設定與優雅關閉〉的流程裡被通知停止並等待它結束。
第 5 個問題:死結與鎖的順序
症狀
服務沒有當掉,CPU 也很低,但某些請求永遠不回應,最後在 Gateway 端全部變成逾時。只有在測試或很小的程式裡,你才會看到 fatal error: all goroutines are asleep - deadlock!。在資料庫那一層,則是偶爾出現 deadlock detected 的錯誤,某一個交易被資料庫強制中止。
為什麼
死結的條件是:A 拿著鎖 1 等鎖 2,B 拿著鎖 2 等鎖 1,彼此永遠等下去。Go 的執行時期只有在所有 goroutine 都卡住時才會報 deadlock;一個 HTTP 伺服器永遠有一個 goroutine 在等新連線,所以部分 goroutine 死結時它完全不會出聲,看起來就只是「卡住」。
Go 程式裡還有幾個特別容易踩的變形:sync.Mutex 不可重入,同一個 goroutine 在已持有鎖的方法裡又呼叫另一個也要拿同一把鎖的方法,會自己卡死自己;sync.RWMutex 在已持有讀鎖時再遞迴拿一次讀鎖,只要中間有寫入者在排隊,也會卡住,因為寫入者在等的期間新的讀鎖要排在它後面;持有鎖的時候去送 channel 或呼叫外部服務,則可能把死結延伸到鎖以外的地方。
資料庫裡的死結也一樣:一張訂單買了商品 A 和 B,另一張訂單買了 B 和 A,兩個交易各自先鎖住第一個商品的庫存列,再去鎖第二個,就互相卡住。PostgreSQL 會偵測到並中止其中一個交易(SQLSTATE 40P01),MySQL InnoDB 則回傳錯誤 1213;被中止的那一方如果沒有重試,使用者就看到下單失敗。
怎麼重現或偵測
Go 這一層,最有效的是看所有 goroutine 的堆疊:對行程送 SIGQUIT(kill -QUIT <pid>)會印出全部堆疊後結束,或者打開 /debug/pprof/goroutine?debug=2 不中斷服務地看。在堆疊裡找 sync.(*Mutex).Lock、semacquire 並注意後面標示的等待時間,例如 [semacquire, 12 minutes],就是卡住很久的鎖。資料庫這一層,PostgreSQL 的日誌會記錄死結的兩個交易與它們等待的鎖,也可以查 pg_locks 搭配 pg_stat_activity 看當下誰在等誰;MySQL 可以用 SHOW ENGINE INNODB STATUS 看最近一次的死結。
怎麼修
最根本的做法是固定取鎖順序:需要同時鎖多個東西時,所有程式都依同一個順序取鎖。以庫存為例,扣多個商品前先把商品 ID 排序,再依序更新或 SELECT … FOR UPDATE,死結就不會發生。其他配套:持有鎖的範圍越小越好,鎖內不做 I/O、不送 channel、不呼叫外部服務;需要重入時把「已持有鎖」的版本拆成一個不拿鎖的內部方法;資料庫交易要短,並且對 40P01、40001 這類錯誤設計有上限的重試。
第 6 個問題:無上限地開 goroutine 與 WaitGroup 誤用
症狀
批次工作或尖峰流量時,服務的記憶體暴增、下游服務被打掛、資料庫回報連線數已滿;或是 wg.Wait() 提早返回,結果還沒算完就被拿去用;偶爾還會看到 panic: sync: negative WaitGroup counter。
為什麼
goroutine 很便宜,於是很容易寫出「每一筆資料開一個 goroutine」的程式。一萬筆訂單就是一萬個同時對下游發出的請求,下游與〈database/sql、交易與連線池〉提到的連線池都承受不住,大量請求在池子外排隊,接著逾時、重試,形成更多請求。goroutine 數量本身不是問題,同時對共享資源施加的壓力才是。
WaitGroup 的常見誤用則有三種:在 goroutine 裡面才呼叫 wg.Add(1),主流程可能在 Add 之前就走到 Wait 並直接返回;Done 的次數比 Add 多,計數變成負數而 panic;把 WaitGroup 以值的方式傳進函式,複製出來的是另一個計數器,go vet 的 copylocks 檢查會抓到這種錯。
怎麼重現或偵測
用接近正式資料量的輸入跑一次批次工作,同時觀察 go_goroutines、下游的請求數與資料庫連線數,壓力是不是隨輸入量線性增加,一看就知道。WaitGroup 的問題用 go vet 與 -race 大多都能抓到。
怎麼修
用號誌(容量固定的 channel)或固定數量的 worker 限制同時進行的數量。下面這段在拿到名額之後才開 goroutine,並且同時監聽 context,主流程被取消時不會再開新的工作:
package main
import (
"context"
"fmt"
"sync"
"sync/atomic"
"time"
)
// notify 模擬寄送訂單通知,一次只允許 limit 個同時進行。
func notifyAll(ctx context.Context, orderIDs []int, limit int) (maxInFlight int64) {
sem := make(chan struct{}, limit) // 號誌:容量就是併發上限
var (
wg sync.WaitGroup
inFlight atomic.Int64
peak atomic.Int64
)
for _, id := range orderIDs { // Go 1.22 起每輪的 id 是新變數
select {
case sem <- struct{}{}: // 拿到名額才開 goroutine
case <-ctx.Done():
wg.Wait()
return peak.Load()
}
wg.Add(1) // 在 go 之前 Add,不要寫在 goroutine 裡
go func() {
defer wg.Done()
defer func() { <-sem }()
cur := inFlight.Add(1)
for { // 記錄同時進行的最大值
p := peak.Load()
if cur <= p || peak.CompareAndSwap(p, cur) {
break
}
}
time.Sleep(5 * time.Millisecond) // 假裝在呼叫外部服務
_ = id
inFlight.Add(-1)
}()
}
wg.Wait()
return peak.Load()
}
func main() {
ids := make([]int, 1000)
for i := range ids {
ids[i] = i + 1
}
peak := notifyAll(context.Background(), ids, 20)
fmt.Println("同時進行的最大數量:", peak)
}執行結果是 同時進行的最大數量: 20,不管輸入有多少筆,同時對下游發出的請求都不會超過 20。號誌的容量應該依下游的承受能力和連線池大小決定,而不是隨便抓一個數字。常用的 golang.org/x/sync/errgroup 也有 SetLimit 可以做到同樣的事,並順便處理「其中一個失敗就取消其他」。至於 WaitGroup,規則是:Add 寫在 go 敘述之前、Done 用 defer、永遠以指標傳遞;Go 1.25 起也可以直接用 wg.Go(func() { ... }),它把 Add 與 Done 都包好了。
第 7 個問題:遺失更新與庫存超賣
症狀
限量商品明明只剩 1 件,卻同時成立了 2 筆訂單;庫存欄位出現負數;或是兩個管理員同時修改商品資料,後存檔的人把前一個人的修改整個蓋掉。
為什麼
這是第 1 個問題搬到資料庫的版本。inventory 服務的扣庫存如果寫成「先 SELECT stock、在 Go 裡判斷夠不夠、再 UPDATE」,兩個交易可能同時讀到 1、同時判斷「夠」、同時扣減。若 UPDATE 寫的是 SET stock = stock - 1,結果變成 -1,也就是超賣;若寫的是在程式裡算好的值 SET stock = 0,庫存數字看起來正確,但其實賣出了兩件,這就是遺失更新。
圖:兩個交易都在對方寫入之前讀到 stock = 1,判斷結果都是「可以賣」;把判斷放進 UPDATE 的 WHERE 條件就能讓第二筆失敗。
很多人以為開了交易就安全了,但交易提供的保證取決於隔離等級。下表整理常見的異常與兩種資料庫預設等級的行為:
| 隔離等級 | 髒讀 | 不可重複讀 | 幻讀 | 遺失更新(讀出來改完寫回) |
|---|---|---|---|---|
| Read Committed(PostgreSQL 預設) | 不會 | 會 | 會 | 會 |
| Repeatable Read(MySQL InnoDB 預設) | 不會 | 不會 | PostgreSQL 不會;InnoDB 一般讀不會,但鎖定讀與更新仍可能看到新列 | PostgreSQL 會報錯要求重試;InnoDB 會發生 |
| Serializable | 不會 | 不會 | 不會 | 不會(衝突的交易會失敗、需要重試) |
幾個容易誤會的細節:PostgreSQL 的 Repeatable Read 是快照隔離,兩個交易更新同一列時,後提交的那個會收到 could not serialize access due to concurrent update(SQLSTATE 40001),應用程式必須重試;但快照隔離仍擋不住「寫入偏斜」(write skew),也就是兩個交易各自讀了對方要改的資料、改了不同的列。MySQL InnoDB 在 Repeatable Read 下,一般的 SELECT 讀的是交易開始時的快照,但 UPDATE 與 SELECT … FOR UPDATE 讀的是最新提交的版本,所以「在程式裡算好再寫回」的遺失更新依然會發生。Serializable 最安全,但衝突時會讓交易失敗,必須搭配重試,並且會降低吞吐量。
怎麼重現或偵測
寫一個整合測試(〈測試:表格驅動、httptest、整合測試〉的做法),把庫存設成 1,同時開 50 個 goroutine 下單,最後斷言「成功的訂單數 ≤ 原始庫存」而且庫存不小於 0。這種測試在本機也很容易重現。正式環境則可以定期跑一個檢查查詢:同一商品的已成立訂單數量加上剩餘庫存,是否等於進貨總量;以及 SELECT * FROM inventory WHERE stock < 0。
怎麼修
依推薦程度排列有三種修法,都把「判斷」和「寫入」合併成資料庫裡的一個原子動作:
-- 保底:資料庫層禁止負數,任何漏網的寫法都會失敗而不是超賣
ALTER TABLE inventory ADD CONSTRAINT stock_non_negative CHECK (stock >= 0);
-- 修法一:條件式 UPDATE(最推薦,一個敘述完成判斷與扣減)
UPDATE inventory
SET stock = stock - $2, updated_at = now()
WHERE product_id = $1 AND stock >= $2;
-- 影響列數 = 1:扣成功;= 0:庫存不足,回報「已售完」
-- 修法二:悲觀鎖,先鎖住這一列再判斷(需要複雜判斷時使用)
BEGIN;
SELECT stock FROM inventory WHERE product_id = $1 FOR UPDATE;
-- 在應用程式裡檢查 stock >= 數量,不夠就 ROLLBACK
UPDATE inventory SET stock = stock - $2 WHERE product_id = $1;
COMMIT;
-- 修法三:樂觀鎖,用 version 欄位偵測「我讀完之後有人改過」
UPDATE inventory
SET stock = $2, version = version + 1
WHERE product_id = $1 AND version = $3;
-- 影響 0 列:有人搶先修改,重新讀取後再試(設上限)修法一在 PostgreSQL 的 Read Committed 下就是正確的:第二個交易會等第一個交易提交,然後針對更新後的那一列重新檢查 WHERE 條件,此時 stock >= 1 已經不成立,於是影響 0 列。Go 這一端只要檢查 result.RowsAffected() 是否為 1,是 0 就回傳 ErrOutOfStock 這類哨兵錯誤(〈錯誤處理:包裝、哨兵、自訂型別〉)。修法二適合判斷邏輯很複雜、無法寫進一個 WHERE 的情況,代價是持鎖期間其他交易都要排隊,所以交易內絕對不能呼叫其他服務。修法三適合衝突很少的情境,例如後台編輯商品資料,在高衝突的搶購場景下大部分請求都會重試失敗,反而更慢。
跨服務時還要多想一步:order 建單和 inventory 扣庫存在不同的資料庫裡,沒辦法放進同一個交易。正確的做法是把扣庫存當成 Saga 的一個步驟,失敗時補償(取消訂單或歸還庫存),詳見〈分散式交易:Saga 與 Outbox〉;扣庫存的請求本身也要帶冪等鍵,避免重試時扣兩次。
第 8 個問題:熱點列(hot row)
症狀
平常一切正常,但某個商品開賣的那一刻,inventory 服務的延遲從幾毫秒飆到幾秒,資料庫的 CPU 卻不高;連線池被佔滿,連帶不相關的商品也下不了單。查看資料庫會發現大量交易都在等同一列的鎖。
為什麼
第 7 個問題的修法讓扣庫存變得正確,代價是同一列的更新必須排隊。每一個 UPDATE 都要拿那一列的寫入鎖,直到交易提交才放開;假設一個交易從開始到提交需要 5 毫秒,這一列理論上每秒最多只能處理約 200 次更新,再多的請求都只能排隊。如果交易裡還做了其他事(寫訂單、寫日誌、甚至呼叫外部服務),持鎖時間更長,吞吐量就更低。多開幾個服務副本完全沒有幫助,因為瓶頸在資料庫的那一列,而且排隊中的交易會一直佔住連線池裡的連線。
怎麼重現或偵測
用壓測工具對同一個商品 ID 同時下單,觀察延遲隨併發數上升的曲線。PostgreSQL 可以查 pg_stat_activity 中 wait_event_type = 'Lock' 的連線數量,以及 pg_locks 中等待同一個 relation 與 tuple 的交易;MySQL 則看 performance_schema.data_lock_waits。
怎麼修
先做最便宜的:讓持鎖時間最短。扣庫存的交易只做扣庫存,其他寫入移到交易外或改用 Outbox 非同步處理;扣庫存放在交易的最後一步再提交,縮短鎖住的時間。
如果還不夠,就把一列拆成多列:把一個商品的庫存分成 N 個「庫存桶」(inventory_buckets 表,每列存一部分庫存),每次隨機挑一個有庫存的桶扣減,總庫存就是所有桶相加。衝突機率大約降為 1/N,代價是查總量要加總、某個桶用完時要換桶重試,最後幾件時會比較麻煩。另一種常見做法是把搶購的扣減移到記憶體型的儲存(例如 Redis 的原子遞減)先擋掉大部分超出庫存的請求,成功的再非同步寫回資料庫,並定期對帳兩邊的數量。也可以把同一商品的扣減請求經由訊息佇列依商品 ID 分區、由單一消費者依序處理,甚至把一小段時間內的多筆扣減合併成一個 UPDATE。這些做法都是用複雜度換吞吐量,應該先量測確認真的是熱點列,再選最簡單足夠的那一個。
第 9 個問題:快取雪崩與驚群效應
症狀
熱門商品的快取一過期,資料庫的 QPS 瞬間暴增好幾十倍,延遲飆高;更糟的情況是資料庫被拖慢後查詢逾時、快取一直建不起來,系統進入「越慢越多請求、越多請求越慢」的循環。服務重啟或快取叢集重開時也會出現同樣的現象。
為什麼
快取未命中時,每個請求都會各自去資料庫查詢再回填。平常沒有問題,但一個熱門 key 過期的那一瞬間,正在讀它的幾百個請求會同時未命中、同時查資料庫,這就是 cache stampede,也稱為驚群效應(thundering herd)。如果大量 key 是在同一時間寫入、設定同樣的 TTL,它們也會在同一時間過期。同樣的形狀還出現在重試:下游恢復的那一刻,所有用固定間隔重試的客戶端同時湧入,又把它打掛。
圖:左邊 N 個請求同時未命中、各自查詢資料庫;右邊經過 singleflight,同一個 key 只放一個請求去查詢,其他人等待並共用結果。
怎麼重現或偵測
在壓測時把某個熱門 key 手動刪除,或把 TTL 設得很短,觀察資料庫查詢數是否出現尖峰。監控上可以把「快取命中率」與「資料庫查詢數」畫在同一張圖,雪崩發生時兩條線會反向大幅變動。
怎麼修
第一步是在行程內合併相同的請求。golang.org/x/sync/singleflight 讓同一個 key 同時只有一個呼叫真的執行,其他呼叫等它完成並拿到同一份結果:
// 片段:internal/inventory/cache.go(需要 golang.org/x/sync/singleflight)
type ProductCache struct {
group singleflight.Group
cache Cache // 本機或 Redis 快取
repo Repository // 讀資料庫
}
func (c *ProductCache) Get(ctx context.Context, id string) (Product, error) {
if p, ok := c.cache.Get(id); ok {
return p, nil
}
v, err, _ := c.group.Do(id, func() (any, error) {
// 不讓第一個呼叫者的取消影響其他等待者,但仍給查詢一個上限
qctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 2*time.Second)
defer cancel()
p, err := c.repo.FindProduct(qctx, id)
if err != nil {
return Product{}, err
}
ttl := 5*time.Minute + time.Duration(rand.Int64N(int64(time.Minute))) // 隨機錯開過期時間
c.cache.Set(id, p, ttl)
return p, nil
})
if err != nil {
return Product{}, err
}
return v.(Product), nil
}這段有兩個細節:Do 裡用的 context 若直接沿用第一個呼叫者的,那個請求一取消,所有等待者都會跟著失敗,所以用 context.WithoutCancel 切斷取消、再自己加逾時;TTL 加上隨機值,讓同一批寫入的 key 不會同時過期。
singleflight 只在單一行程內有效,inventory 有 10 個副本就最多還是有 10 個查詢。這通常已經足夠;不夠的話可以再加上:在過期前提早由背景更新(只有一個人負責更新、其他人繼續讀舊值,即 stale-while-revalidate)、用分散式鎖讓整個叢集只有一個副本重建快取(〈冪等與分散式鎖〉談過鎖的限制)、對查不到的 key 也短暫快取「不存在」,避免穿透。重試造成的驚群則靠指數退避加上隨機抖動與熔斷,見〈逾時、重試與熔斷〉。
第 10 個問題:訊息被重複處理
症狀
同一筆訂單寄出兩封「付款成功」通知;庫存被扣了兩次;會員點數多加了一次。查日誌會看到同一個訊息 ID 被消費者處理了兩次,有時間隔幾毫秒,有時間隔好幾分鐘。
為什麼
〈訊息佇列與事件驅動〉提過,大多數訊息佇列提供的是至少一次(at-least-once)的投遞保證。消費者處理完副作用、但還沒來得及確認(ack 或提交 offset)就當掉、被重新部署或發生分區重新分配,這則訊息就會再被投遞一次;生產者送出後沒收到確認而重送,佇列裡也會出現兩則內容相同的訊息。這不是佇列的錯誤,而是分散式系統的本質:「處理」與「確認」是兩個動作,中間永遠可能失敗。這和第 1 個問題一樣是讀改寫的競爭,只是兩個執行者可能是同一個消費者的前後兩次。
怎麼重現或偵測
在測試裡直接把同一則訊息送進處理函式兩次,斷言最終狀態與只送一次相同;在壓測環境中,在處理完成、確認之前隨機讓消費者結束行程。正式環境可以在日誌與追蹤裡記錄訊息 ID,定期統計同一 ID 被處理的次數。
怎麼修
讓消費者冪等,而不是追求「恰好一次」的投遞。最可靠的做法是在同一個資料庫交易裡寫入業務資料與「已處理訊息」紀錄:建立 processed_messages(consumer, message_id) 並設唯一約束,先 INSERT … ON CONFLICT DO NOTHING,影響 0 列就代表處理過了,直接確認並跳過;影響 1 列才執行業務更新,最後一起提交。另一個常見的做法是讓業務操作本身就冪等,例如 UPDATE orders SET status = 'paid' WHERE id = $1 AND status = 'pending',重複執行第二次只會影響 0 列。生產者這一端,用 Outbox 確保「寫入資料」與「送出事件」一致(〈分散式交易:Saga 與 Outbox〉),冪等鍵的設計細節則在〈冪等與分散式鎖〉。
提示:寄信、推播、呼叫外部 API 這類副作用無法放進資料庫交易。做法是先在交易裡記下「要寄」,再由另一個步驟依紀錄寄送並標記完成,重複時只會看到「已寄過」。
一張表看完
| # | 問題 | 典型症狀 | 怎麼偵測 | 怎麼修 |
|---|---|---|---|---|
| 1 | 資料競爭 | 數字偶爾不對、欄位彼此矛盾 | go test -race | mutex、atomic、單一擁有者 |
| 2 | map 併發寫入 | fatal error: concurrent map writes | -race、fatal 堆疊 | RWMutex、分片、整份替換 |
| 3 | 迴圈變數被捕獲 | 處理到重複或錯的元素 | go vet、檢查 go.mod 版本 | Go 1.22+、當參數傳入 |
| 4 | goroutine 洩漏 | 記憶體與 goroutine 數只升不降 | pprof goroutine profile、goleak | context 取消、緩衝 channel、defer cancel() |
| 5 | 死結 | 請求卡住不回應、deadlock detected | goroutine dump、pg_locks | 固定取鎖順序、縮小鎖範圍、重試 |
| 6 | 無上限 goroutine、WaitGroup 誤用 | 下游被打掛、Wait 提早返回 | 觀察資源隨輸入成長、go vet | 號誌/worker pool、Add 在 go 之前 |
| 7 | 遺失更新與超賣 | 庫存負數、成交數超過庫存 | 併發整合測試、對帳查詢 | 條件式 UPDATE、FOR UPDATE、version 欄位 |
| 8 | 熱點列 | 單一商品開賣時延遲暴增 | 鎖等待統計 | 縮短交易、拆庫存桶、預扣與佇列 |
| 9 | 快取雪崩 | 快取過期瞬間資料庫尖峰 | 命中率與查詢數對照 | singleflight、隨機 TTL、背景更新 |
| 10 | 訊息重複處理 | 重複通知、重複扣減 | 同一訊息 ID 計數 | 冪等消費者、去重表、Outbox |
重點整理
- 所有併發問題的根源都是「多個執行者同時對同一份狀態讀改寫」,差別只在共享的是變數、資料庫的一列、快取 key 還是訊息。
go test -race要放進 CI,而且測試要真的製造併發;它沒有誤報,但只抓得到實際跑到的競爭。- 單一數值用 atomic,多個欄位要一起一致或「檢查後再寫」就用 mutex;把欄位都換成 atomic 不等於沒有競爭條件。
- map 併發寫入是無法 recover 的 fatal error,共享的 map 一定要上鎖或改用整份替換。
- 確認
go.mod的go版本,Go 1.22 起迴圈變數每輪都是新的;值當參數傳進 goroutine 最清楚。 - 每個 goroutine 都要有明確的結束條件;用 pprof 的 goroutine profile 找洩漏,用 goroutine dump 找死結。
- 同時取多把鎖、鎖多個資料列時,一律固定順序;鎖內不做 I/O。
- 用號誌或 worker pool 限制同時對下游施加的壓力,
wg.Add寫在go之前。 - 扣庫存把判斷寫進 UPDATE 的 WHERE,檢查影響列數,再加上
CHECK (stock >= 0)當最後一道防線;交易不等於安全,要知道自己用的隔離等級。 - 熱點列先縮短交易,再考慮拆桶、預扣或依商品排隊;快取雪崩用 singleflight 加隨機 TTL;訊息一定會重複,消費者必須冪等。
下一篇
併發問題裡最昂貴的一種,是發生在錢上面的。下一篇〈支付常見問題:重複扣款、回呼與對帳〉把 payment 服務會遇到的重複扣款、回呼順序、金額計算與每日對帳,一個一個拆開來看。