This resume is also available in English.

五、上線與維運第 4 / 4 篇 · 全部目錄

專欄 › 五、上線與維運 › 第 20 篇

效能調校:pprof 與 benchmark

Performance Tuning in Go: pprof and Benchmarks

先用 testing.B 與 Go 1.24 的 b.Loop 寫出可信的 benchmark,以 benchstat 比較改動前後;再用 pprof 分析 CPU、記憶體、goroutine 與鎖競爭,理解逃逸分析與配置成本,最後調整 GOMAXPROCS、GOGC、GOMEMLIMIT 並套用 PGO。

  • Go
  • Performance
  • pprof
這篇的步驟
  1. 這篇要解決什麼
  2. 第 1 步:用 testing.B 寫 benchmark
  3. 第 2 步:用 benchstat 比較,而不是看一次結果
  4. 第 3 步:用 pprof 找出 CPU 與記憶體熱點
  5. 第 4 步:在執行中的服務上取樣:net/http/pprof
  6. 第 5 步:逃逸分析與記憶體配置
  7. 第 6 步:GOMAXPROCS、GOGC 與 GOMEMLIMIT
  8. 第 7 步:PGO:讓編譯器依實際負載最佳化
  9. 常見陷阱
  10. 重點整理
  11. 下一篇

上一篇〈Docker 與 Kubernetes 部署(單一服務)〉我們把訂單服務打包成映像檔,在叢集裡設好資源請求與限制;這篇接著回答那些數字背後的問題:服務到底把 CPU 與記憶體花在哪裡,又該怎麼有根據地讓它變快、變省。

這篇要解決什麼

效能問題最常見的處理方式,是憑直覺改:「這裡用了 fmt.Sprintf,應該很慢」「改成指標傳遞比較省」「加個快取吧」。直覺有時候對,但更多時候改了半天,真正的瓶頸在完全不同的地方;或者改完之後到底有沒有變快,也只是「感覺」。

Go 的工具鏈為效能工作提供了一整套內建工具,原則只有一句話:先量測,再修改,再量測。這篇會依序介紹:

  1. 用 testing.B 寫 benchmark,量測單一函式的耗時與記憶體配置。
  2. 用 benchstat 判斷改動前後的差異是否真實,而不是雜訊。
  3. 用 pprof 找出整個程式裡 CPU、記憶體、goroutine 與鎖的熱點,包括在正式環境的服務上安全地取樣。
  4. 理解逃逸分析與記憶體配置,知道哪些寫法會讓值跑到堆積上。
  5. 調整 GOMAXPROCS、GOGC、GOMEMLIMIT 這些執行環境參數,以及用 PGO 讓編譯器依據實際負載最佳化。

範例延續 internal/order 的訂單服務:一個把訂單內容組成摘要字串的函式,以及處理下單請求的 HTTP 服務。

第 1 步:用 testing.B 寫 benchmark

benchmark 和測試寫在同一個 _test.go 檔案裡,函式名稱以 Benchmark 開頭,接收 *testing.B。Go 1.24 起推薦使用 for b.Loop() { ... } 的寫法,取代舊的 for i := 0; i < b.N; i++。b.Loop 有幾個好處:迴圈之前的準備工作自動不計時,不需要再呼叫 b.ResetTimer;迴圈主體裡的函式呼叫與它的參數、回傳值不會被編譯器當成無用程式碼刪掉,所以不必再把結果指派給全域變數來「騙過」最佳化;整個 benchmark 函式也只會被執行一次,昂貴的準備工作不會重複進行。

下面是一個完整、可以直接執行的測試檔。它比較兩種組出訂單摘要的寫法:一種用字串相加與 fmt.Sprintf,另一種用預先配置容量的 strings.Builder 與 strconv。

package order

import (
	"fmt"
	"strconv"
	"strings"
	"testing"
)

type Item struct {
	SKU   string
	Qty   int
	Price int64 // 以「分」為單位
}

type Order struct {
	ID     string
	UserID string
	Items  []Item
	Total  int64
	Status string // pending / paid / cancelled
}

// SummaryNaive 以字串相加與 fmt.Sprintf 組出摘要。
func SummaryNaive(o *Order) string {
	s := "order " + o.ID + ":"
	for _, it := range o.Items {
		s += fmt.Sprintf(" %s x%d", it.SKU, it.Qty)
	}
	return s
}

// SummaryBuilder 預先估算容量,避免反覆配置與 fmt 的格式化成本。
func SummaryBuilder(o *Order) string {
	var b strings.Builder
	b.Grow(len("order :") + len(o.ID) + len(o.Items)*16)
	b.WriteString("order ")
	b.WriteString(o.ID)
	b.WriteByte(':')
	for _, it := range o.Items {
		b.WriteByte(' ')
		b.WriteString(it.SKU)
		b.WriteString(" x")
		b.WriteString(strconv.Itoa(it.Qty))
	}
	return b.String()
}

func newOrder(n int) *Order {
	o := &Order{ID: "A123", UserID: "u-42", Status: "pending"}
	for i := range n {
		o.Items = append(o.Items, Item{SKU: "SKU-" + strconv.Itoa(i), Qty: i%3 + 1, Price: 1990})
		o.Total += int64(i%3+1) * 1990
	}
	return o
}

// 先確認兩種寫法結果一致,benchmark 才有比較的意義。
func TestSummaryEqual(t *testing.T) {
	for _, n := range []int{0, 1, 10, 100} {
		o := newOrder(n)
		if got, want := SummaryBuilder(o), SummaryNaive(o); got != want {
			t.Fatalf("n=%d: got %q, want %q", n, got, want)
		}
	}
}

func BenchmarkSummary(b *testing.B) {
	for _, n := range []int{1, 10, 100} {
		o := newOrder(n) // 準備工作:不計入時間
		b.Run(fmt.Sprintf("naive/items=%d", n), func(b *testing.B) {
			b.ReportAllocs()
			for b.Loop() {
				SummaryNaive(o)
			}
		})
		b.Run(fmt.Sprintf("builder/items=%d", n), func(b *testing.B) {
			b.ReportAllocs()
			for b.Loop() {
				SummaryBuilder(o)
			}
		})
	}
}

這個範例示範了幾個寫 benchmark 的好習慣:

  • 先寫測試證明行為相同。最佳化最怕的是「變快了但結果錯了」。TestSummaryEqual 讓重構有安全網,這和〈測試:表格驅動、httptest、整合測試〉的精神一致。
  • 用子 benchmark 掃過不同規模。b.Run 讓同一個 benchmark 涵蓋 1、10、100 個品項。兩種寫法在規模小時可能差不多,規模大時差距才拉開;只量一種大小容易得出片面的結論。
  • b.ReportAllocs() 會在結果中加上每次操作的配置次數(allocs/op)與配置位元組數(B/op)。在 Go 裡,記憶體配置往往比純計算更貴,因為它還帶來垃圾回收的負擔。

執行 go test -bench=Summary -benchmem 會看到每個子 benchmark 的 ns/op、B/op、allocs/op。ns/op 是每次操作平均耗時,名稱後面的 -8 之類的數字是執行時的 GOMAXPROCS。

第 2 步:用 benchstat 比較,而不是看一次結果

benchmark 結果天生有雜訊:CPU 頻率調整、其他程式搶資源、作業系統排程,都會讓同一段程式碼每次跑出不同數字。只跑一次就說「快了 5%」,很可能只是運氣。

正確的做法是每個版本都跑多次,再用 benchstat 做統計比較。假設在 benchmark 裡只保留一個 Summary 函式,先用字串相加的寫法量一次,改成 strings.Builder 之後再量一次:

# 安裝 benchstat(golang.org/x/perf 的工具)
go install golang.org/x/perf/cmd/benchstat@latest

# 改動前:跑 10 次存成 old.txt
go test -run '^$' -bench=Summary -benchmem -count=10 ./internal/order > old.txt

# 修改程式後:同樣條件再跑一次
go test -run '^$' -bench=Summary -benchmem -count=10 ./internal/order > new.txt

# 統計比較
benchstat old.txt new.txt

-run '^$' 表示不執行任何一般測試,只跑 benchmark。benchstat 的輸出大致如下(數字僅為示意,實際結果依機器而定):

                        │   old.txt   │               new.txt               │
                        │   sec/op    │   sec/op     vs base                │
Summary/items=1-8         410.0n ± 3%   47.0n ± 2%  -88.54% (p=0.000 n=10)
Summary/items=10-8        3.10µ ± 2%    0.43µ ± 1%  -86.13% (p=0.000 n=10)
Summary/items=100-8       18.40µ ± 4%   1.12µ ± 2%  -93.91% (p=0.000 n=10)
geomean                   3.03µ         0.28µ       -90.14%

要看懂三個欄位:± 2% 是變異範圍,太大代表量測環境不穩定;p= 是統計檢定的 p 值,通常小於 0.05 才視為顯著差異;~ 表示兩者沒有顯著差別。上面的示意結果在三種規模下都顯著,而且差距隨品項數擴大。但要記得,這只說明「這個函式」變快了:如果組摘要只占整個請求耗時的一小部分,使用者感受到的改善可能微乎其微。函式層級的進步要放回整體去衡量,這就是下一步要用 profile 看整個程式的原因。

量測時盡量讓環境穩定:關掉其他耗資源的程式、筆電接上電源、新舊版本在同一台機器上交替執行。

第 3 步:用 pprof 找出 CPU 與記憶體熱點

benchmark 回答的是「這個函式多快」,但前提是你已經知道要看哪個函式。真實的服務裡,問題通常是「整個請求為什麼慢」「記憶體為什麼一直長」,這時候要用 profile:在程式執行期間定期取樣,統計時間或記憶體花在哪些函式上。

Go 內建幾種 profile:

Profile回答的問題取樣方式
CPU哪些函式最耗 CPU 時間?每秒約 100 次中斷並記錄當下的呼叫堆疊
heap誰配置了記憶體?目前堆積上存活的是什麼?依配置量取樣,分 inuse_* 與 alloc_* 兩種檢視
goroutine現在有哪些 goroutine、各自卡在哪裡?快照所有 goroutine 的堆疊
mutex哪些鎖競爭最嚴重?需設定取樣率,記錄等待持有者釋放鎖的時間
blockgoroutine 在哪裡阻塞(channel、鎖、select)?需設定取樣率

最簡單的取得方式,是在跑 benchmark 時順便產生 profile:go test -bench=Summary -cpuprofile=cpu.out -memprofile=mem.out。接著用 go tool pprof 分析。pprof 最實用的介面是網頁版,go tool pprof -http=:8081 cpu.out 會開啟瀏覽器,裡面有呼叫圖、火焰圖、原始碼對照等檢視。

閱讀 profile 時有兩個關鍵數字:flat 是函式「自己」花的時間,cum(cumulative)是函式加上它呼叫的所有函式總共花的時間。flat 高的函式是真正在做事的熱點;cum 高但 flat 低的函式,代表它的成本來自底下的呼叫,要往下追。

火焰圖把這些資訊畫成一張圖:橫軸是占用比例(不是時間順序),縱軸是呼叫深度,越寬的方塊越值得注意。

net/http.(*conn).serve order.(*Handler).Create encoding/json.Unmarshal order.SummaryNaive reflect fmt.Sprintf concatstrings runtime.mallocgc(配置記憶體) ↑ 呼叫深度 寬度 = 占用比例(不是時間順序)→

圖:火焰圖的寬度代表占用比例,最上層又寬的方塊是 flat 高的熱點;這個示意中,格式化與記憶體配置占了處理請求的大部分。

heap profile 的兩種檢視用途不同:inuse_space 看的是「現在」堆積上存活的物件,適合追查記憶體洩漏或常駐記憶體過高;alloc_space 看的是「累計」配置了多少,適合找出製造大量短命物件、讓垃圾回收很忙的地方。很多服務的 CPU profile 裡,runtime.mallocgc 與 GC 相關函式占了可觀的比例,這時候降低配置量往往比優化計算更有效。

第 4 步:在執行中的服務上取樣:net/http/pprof

benchmark 與測試裡的 profile 只反映測試資料的情況。真正的負載形狀要在正式環境才看得到,net/http/pprof 讓你透過 HTTP 從執行中的服務取得 profile。它的開銷很低:CPU profile 只在你要求的那 30 秒左右進行取樣,heap 的取樣一直都在進行、成本很小。

但 pprof 端點會洩漏程式內部資訊,CPU profile 也有一定成本,絕對不能對外公開。下面的完整範例把 pprof 掛在只監聽本機的獨立管理埠上,與對外服務的埠分開:

package main

import (
	"log/slog"
	"net/http"
	"net/http/pprof"
	"os"
	"runtime"
	"strconv"
	"sync"
)

var (
	mu    sync.Mutex
	stock = map[string]int{"SKU-1": 1_000_000}
)

// reserve 模擬庫存預留:一把全域鎖,負載一高就會出現競爭。
func reserve(sku string, qty int) bool {
	mu.Lock()
	defer mu.Unlock()
	if stock[sku] < qty {
		return false
	}
	stock[sku] -= qty
	return true
}

func main() {
	// mutex 與 block profile 預設關閉,需要設定取樣率。
	runtime.SetMutexProfileFraction(10) // 約每 10 次競爭記錄 1 次
	runtime.SetBlockProfileRate(10_000) // 約每阻塞 10µs 取樣一次

	// 管理埠:只聽 localhost,透過 kubectl port-forward 存取。
	admin := http.NewServeMux()
	admin.HandleFunc("/debug/pprof/", pprof.Index) // heap、goroutine、mutex、block 等都由它處理
	admin.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
	admin.HandleFunc("/debug/pprof/profile", pprof.Profile)
	admin.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
	admin.HandleFunc("/debug/pprof/trace", pprof.Trace)
	go func() {
		if err := http.ListenAndServe("127.0.0.1:6060", admin); err != nil {
			slog.Error("admin server", "err", err)
		}
	}()

	app := http.NewServeMux()
	app.HandleFunc("POST /orders", func(w http.ResponseWriter, r *http.Request) {
		qty, _ := strconv.Atoi(r.URL.Query().Get("qty"))
		if qty < 1 {
			qty = 1
		}
		if !reserve("SKU-1", qty) {
			http.Error(w, "out of stock", http.StatusConflict)
			return
		}
		w.WriteHeader(http.StatusCreated)
		_, _ = w.Write([]byte("ok"))
	})
	slog.Info("listening", "app", ":8080", "admin", "127.0.0.1:6060")
	if err := http.ListenAndServe(":8080", app); err != nil {
		slog.Error("app server", "err", err)
		os.Exit(1)
	}
}

常見的寫法 import _ "net/http/pprof" 會把這些路徑註冊到 http.DefaultServeMux。如果對外的伺服器剛好也用 DefaultServeMux(例如 http.ListenAndServe(":8080", nil)),pprof 就會意外對外公開。上面的範例明確使用自己的 ServeMux,對外服務完全不會有 /debug/pprof/ 路徑。

取得 profile 的方式:

# 從叢集把管理埠轉到本機
kubectl port-forward deploy/order 6060:6060

# CPU:取樣 30 秒並開網頁介面
go tool pprof -http=:8081 'http://localhost:6060/debug/pprof/profile?seconds=30'

# 記憶體:目前存活的物件;加上 -sample_index=alloc_space 看累計配置
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/heap

# goroutine:數量持續增加時,看它們都卡在哪一行
curl -s 'http://localhost:6060/debug/pprof/goroutine?debug=1' | head -50

# 鎖競爭
go tool pprof -http=:8081 http://localhost:6060/debug/pprof/mutex

# 比較兩個時間點的 heap,找出增長的部分
go tool pprof -http=:8081 -diff_base=heap-1.pb.gz heap-2.pb.gz

# 逃逸分析:看哪些變數被移到堆積上
go build -gcflags='-m' ./internal/order 2>&1 | grep -E 'escapes|moved to heap'

goroutine profile 是排查洩漏最直接的工具:〈可觀測性:日誌、指標、追蹤〉提到 go_goroutines 指標只升不降時,用 debug=1 看彙總後的堆疊,通常會發現數千個 goroutine 卡在同一行的 channel 傳送或接收上,再對照〈Goroutine、Channel 與並發模式〉檢查是誰忘了取消或關閉。

mutex profile 會指出像上面 reserve 這種全域鎖的競爭。解法通常是縮小臨界區、依鍵分片(例如依 SKU 分成多把鎖),或改用不需要鎖的設計。範例裡的鎖只是示意,跨執行個體的庫存正確性還是要靠資料庫或〈冪等與分散式鎖〉談的機制。

提示:每種 profile 都只是取樣,數字代表比例,不是精確計數。比較前後兩次 profile 時,負載條件要盡量相同,否則差異可能只是流量不同。

第 5 步:逃逸分析與記憶體配置

Go 的變數可能放在堆疊(stack)或堆積(heap)上。堆疊上的配置幾乎沒有成本,函式回傳時一起釋放;堆積上的配置需要記憶體配置器處理,之後還要由垃圾回收器追蹤與回收。編譯器透過逃逸分析決定每個變數放哪裡:如果編譯器無法證明一個值在函式結束後不再被使用,它就會「逃逸」到堆積上。

用 go build -gcflags='-m' 可以看到編譯器的判斷,輸出會出現像「&Order{...} escapes to heap」「moved to heap: buf」「leaking param: o」這類訊息。常見的逃逸原因有:

  • 回傳區域變數的指標。值必須在函式結束後繼續存在,只能放堆積。
  • 存進介面。把具體值轉成 any 或其他介面(例如傳給 fmt.Sprintf 的參數),在很多情況下會導致配置。這正是第 1 步 SummaryNaive 較慢的原因之一。
  • 閉包捕獲變數,並且這個閉包的生命週期超出目前函式(例如交給 goroutine)。
  • 大小在編譯期未知的切片,例如 make([]byte, n) 且 n 是變數,或大小超過堆疊配置的上限。
  • 切片或 map 的元素是指標,被存放的值本身也常會跟著逃逸。

降低配置的常用技巧:

技巧說明
預先配置容量make([]T, 0, n)、strings.Builder.Grow、make(map[K]V, n),避免擴容時反覆配置與複製
重用緩衝區熱路徑上用 sync.Pool 重用暫存物件,例如編碼用的 bytes.Buffer;放回前記得重設
避免不必要的介面轉換熱路徑用 strconv 取代 fmt,用具體型別取代 any
傳值而非指標小型結構傳值不一定比傳指標慢,還可能避免逃逸;以 benchmark 為準
減少中間字串[]byte 與 string 之間的轉換常會配置,處理過程中盡量維持同一種型別

但要記得:逃逸分析的輸出是線索,不是目標。只有 profile 顯示配置確實是熱點時,才值得為了減少配置而犧牲可讀性。把每一個 escapes to heap 都消滅,通常只是浪費時間。

第 6 步:GOMAXPROCS、GOGC 與 GOMEMLIMIT

程式碼之外,Go 執行環境本身也有幾個影響效能的參數:

GOMAXPROCS 決定同時執行 Go 程式碼的作業系統執行緒數量上限,預設等於可用的 CPU 數。在容器裡,「可用的 CPU 數」是關鍵:較舊的 Go 版本只看機器的核心數,如果節點有 32 核,而容器的 CPU limit 只有 2 核,Go 會開 32 個執行緒搶 2 核的配額,結果是頻繁被節流、延遲不穩。Go 1.25 起,在 Linux 上的預設值會考慮 cgroup 的 CPU limit,並在 limit 改變時自動調整;使用較舊版本時,常見做法是用社群套件在啟動時依 cgroup 設定,或直接以環境變數指定。

GOGC 控制垃圾回收的頻率,預設為 100,意思是「當堆積相對於上次回收後的存活量成長 100% 時,觸發下一次回收」。調高(例如 200)會讓 GC 次數變少、CPU 用量下降,但記憶體尖峰變高;調低則相反。GOGC=off 會完全關閉以比例觸發的回收。

GOMEMLIMIT(Go 1.19 起)是記憶體的軟上限。當總記憶體接近這個值時,GC 會更積極地執行,盡量不超過它。這解決了單靠 GOGC 很難處理的問題:在容器裡,你在意的其實是「不要超過 memory limit 被 OOM 終止」,而不是成長比例。

時間 → 記憶體 容器 memory limit GOMEMLIMIT 只有 GOGC:存活量成長 100% 才回收 負載升高:接近上限時提前回收

圖:GOGC 以比例決定回收時機;設定 GOMEMLIMIT 後,接近上限時回收會提前發生,讓記憶體保持在容器限制之下。

兩者常見的搭配方式:

  • 一般服務:保留 GOGC=100,把 GOMEMLIMIT 設為容器 memory limit 的八、九成左右(上一篇的 Deployment 示範了用 resourceFieldRef 注入 limit 的方式,實務上可以再乘上一個比例)。
  • 記憶體充裕、想省 CPU 的服務:把 GOGC 調高或設為 off,完全交給 GOMEMLIMIT 控制,讓 GC 只在接近上限時才頻繁執行。

但要注意一個陷阱:如果存活的資料本身就接近 GOMEMLIMIT,GC 會不停地執行卻回收不了多少,CPU 被 GC 吃光,這種情況稱為 GC 抖動(thrashing)。Go 的執行環境對此有保護機制,會限制 GC 占用的 CPU 比例,此時記憶體可能超過軟上限,最後仍然會被 OOM 終止。也就是說,GOMEMLIMIT 不能取代「給足記憶體」;當 heap profile 顯示存活資料確實很大時,該做的是減少常駐資料或調高 limit。

要觀察 GC 的實際行為,可以設定 GODEBUG=gctrace=1,每次回收都會在標準錯誤輸出一行摘要,包括回收前後的堆積大小與耗時。新版 Go 的垃圾回收器實作也在持續改進,升級 Go 版本本身就可能帶來可量測的改善,這也是升級時值得重跑 benchmark 的原因之一。

第 7 步:PGO:讓編譯器依實際負載最佳化

Profile-Guided Optimization(PGO)自 Go 1.21 起正式可用:把一份代表正式環境負載的 CPU profile 交給編譯器,編譯器會針對熱點函式做更積極的內聯(inlining)與其他最佳化,例如把熱路徑上的介面方法呼叫改成直接呼叫。官方文件提到的典型改善幅度大約在幾個百分點,實際效果依程式而定。

使用方式非常簡單:

  1. 從正式環境的服務取得 CPU profile(第 4 步的 /debug/pprof/profile?seconds=30),最好能涵蓋具代表性的負載,必要時合併多個執行個體的 profile(go tool pprof -proto a.pprof b.pprof > merged.pprof)。
  2. 把檔案命名為 default.pgo,放在主套件的目錄,也就是 cmd/order/default.pgo。
  3. 照常 go build。-pgo=auto 是預設值,會自動使用主套件目錄下的 default.pgo。

default.pgo 應該提交進版本控制,讓建置可重現;〈Docker 與 Kubernetes 部署(單一服務)〉的多階段 Dockerfile 不需要任何修改,COPY . . 會把它一起帶進建置階段。之後定期(例如每次大版本發布前)重新取樣更新即可;用稍舊的 profile 建置新版本程式碼也沒問題,PGO 對程式碼變動有一定的容忍度。

整個效能工作的循環可以畫成下面這樣:

指標發現問題 P99、CPU、記憶體 pprof 定位熱點 CPU、heap、mutex benchmark 驗證 -count+benchstat 部署並再量測 更新 default.pgo

圖:從指標發現問題、用 profile 定位熱點、以 benchmark 驗證修改,再回到正式環境確認效果,每一圈都以量測為依據。

常見陷阱

  • 憑直覺最佳化。沒有 profile 就改程式,很可能改到不是瓶頸的地方,還讓程式更難讀。
  • 只跑一次 benchmark。雜訊可能大於差異。用 -count 多跑幾次,交給 benchstat 判斷是否顯著。
  • benchmark 被編譯器最佳化掉。舊寫法若沒有使用結果,整個呼叫可能被刪除,跑出不合理的超快數字。用 b.Loop(Go 1.24+)可以避免。
  • 準備工作被計入時間。在舊寫法裡忘了 b.ResetTimer,建立測試資料的時間被平均進結果。b.Loop 會自動排除迴圈之前的準備。
  • 測試資料不具代表性。只量 1 個品項,或只量 1 萬個品項,結論都可能與實際負載不符。用子 benchmark 掃過不同規模,並以正式環境的資料分布為準。
  • pprof 對外公開。使用 DefaultServeMux 又匯入 net/http/pprof,等於把內部資訊與一個可以消耗 CPU 的端點交給所有人。掛在獨立的內部埠上。
  • 在容器裡忽略 GOMAXPROCS 與 CPU limit。舊版 Go 會依節點核心數開執行緒,造成大量節流。確認版本行為或明確設定。
  • 把 GOMEMLIMIT 當成萬靈丹。存活資料本身太大時,GC 只會空轉。先用 heap profile 確認記憶體到底被誰占用。
  • 過度最佳化。sync.Pool、手動緩衝區重用、避免介面,都會增加程式的複雜度。只在 profile 證明值得的熱路徑上使用。

重點整理

  • 效能工作的原則是「量測 → 修改 → 再量測」,任何最佳化都要有數據支持。
  • benchmark 用 for b.Loop()(Go 1.24+)與 b.ReportAllocs(),以子 benchmark 掃過不同規模,並先用測試確認新舊行為一致。
  • 用 -count 多次執行並以 benchstat 比較,看變異範圍與 p 值,不要被雜訊誤導。
  • pprof 提供 CPU、heap、goroutine、mutex、block 等 profile;分清 flat 與 cum、inuse 與 alloc 的差別,用火焰圖找寬的方塊。
  • net/http/pprof 掛在只對內的獨立埠上,透過 port-forward 取樣,不要使用預設的 DefaultServeMux 對外。
  • 逃逸分析(-gcflags=-m)解釋配置從哪裡來;減少熱路徑上的配置往往比優化計算更有效。
  • 在容器裡留意 GOMAXPROCS 與 CPU limit 的關係;以 GOMEMLIMIT 搭配 GOGC 控制記憶體,但它不能取代足夠的記憶體。
  • PGO 只要把正式環境的 CPU profile 放成主套件目錄下的 default.pgo,就能讓編譯器依實際負載最佳化。

下一篇

到這裡,單一服務已經看得見、關得乾淨、打包得好、也量測過效能;但實際的系統是 api-gateway、order、payment、inventory 加上資料庫與訊息佇列一起運作的。下一部分從〈用 Docker Compose 部署整套微服務〉開始,把整套系統在一台機器上完整跑起來。