学完这篇,你能独立写出不含水分的 Go 基准函数,看懂 go test -bench 输出里每个数字的含义,并且能用统计数据判断一次优化到底是真有提升还是机器在抖。
第一步:写第一个基准函数
基准函数放在 _test.go 文件里,命名必须是 Benchmark 开头、参数为 *testing.B。被测代码用 b.N 循环包起来:
// str_test.go
package demo
import "testing"
var sink string
func BenchmarkConcat(b *testing.B) {
for i := 0; i < b.N; i++ {
sink = "foo" + "bar"
}
}
注意 sink 是包级变量。如果写成 _ = "foo" + "bar",编译器在优化阶段就能算出结果,这段循环会被整个消掉,测出来是 0.3 ns/op 这种假数据。把结果赋给一个外部可见的变量,才保证代码真被执行。
注意:b.N 是测试框架动态给的,会先小后大逐步放大到时长够为止。你不能在循环里写 for i := 0; i < 1000; i++,那样测出来的不是单次成本。
第二步:把准备工作移出计时区
真实场景几乎都要先准备数据,比如造一段 1MB 的输入。这些不能算进指标里:
func BenchmarkParse(b *testing.B) {
data := make([]byte, 1<<20)
fillData(data) // 准备数据
b.ReportAllocs() // 顺便统计内存分配
b.SetBytes(int64(len(data)))// 用于换算 MB/s
b.ResetTimer() // 从这里开始计时
for i := 0; i < b.N; i++ {
Parse(data)
}
}
b.StopTimer() / b.StartTimer() 适合循环内部需要间歇性做非被测工作的场景,但用得越多噪声越大,优先考虑重构掉。
第三步:跑起来
最常用的组合是这条:
go test -run '^$' -bench . -benchmem -count 5 ./pkg/...
逐个参数说:
-run '^$':正则匹配不到任何测试函数,跳过普通 Test,只跑基准
-bench .:跑所有基准;也可以 -bench=BenchmarkParse 精确指定
-benchmem:输出 B/op 和 allocs/op
-count 5:每个基准重复 5 轮,用来看波动范围
-benchtime=2s:默认每轮 1 秒,跑长一点更稳;也可以 -benchtime=1000x 指定固定执行 1000 次
-cpu=1,2,4:分别用不同 GOMAXPROCS 跑,看并发扩展性
第四步:读懂输出
典型输出长这样:
BenchmarkParse-8 2000 524288 ns/op 2.00 MB/s 12 B/op 2 allocs/op
-8:GOMAXPROCS=8 时的结果,不是版本号
2000:这一轮实际执行了 2000 次
524288 ns/op:单次耗时,最重要的一列
2.00 MB/s:只有调了 SetBytes 才有,表示吞吐
12 B/op:单次操作分配字节数;不调 ReportAllocs 或加 -benchmem 不显示
2 allocs/op:单次操作分配次数
实际优化中,allocs/op 往往比 ns/op 更值得盯——每次分配都是 GC 未来的负担,把 3 次降到 1 次,通常比抠几纳秒收益大得多。
第五步:用 benchstat 判断真假提升
单次运行的差异可能纯属噪声。改动前后各采一组样本,交给官方统计工具:
go install golang.org/x/perf/cmd/benchstat@latest
go test -run '^$' -bench . -count 10 > old.txt # 改动前
go test -run '^$' -bench . -count 10 > new.txt # 改动后
benchstat old.txt new.txt
输出会给出中位数、变化百分比和 p 值。p 值大于 0.05 的差异不要当成提升,尤其 -count 小于 5 时基本没参考价值。
注意:两次采样要在同一台机器、同一个电源模式、尽量空载的条件下做。笔记本插拔电源、后台跑编译、CPU 降频,都能轻松造出 20% 的假差异。
第六步:子基准与并行基准
不同输入规模用子基准展开,结果会以 / 分层,benchstat 也能正确对齐:
func BenchmarkParseSize(b *testing.B) {
for _, n := range []int{1 << 10, 1 << 16, 1 << 20} {
b.Run(fmt.Sprintf("size=%d", n), func(b *testing.B) {
data := make([]byte, n)
b.SetBytes(int64(n))
b.ResetTimer()
for i := 0; i < b.N; i++ {
Parse(data)
}
})
}
}
测并发扩展用 RunParallel,框架会自动把负载分摊到 GOMAXPROCS 个 goroutine:
func BenchmarkCacheGet(b *testing.B) {
c := NewCache()
c.Set("k", "v")
b.ResetTimer()
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
c.Get("k")
}
})
}
注意:RunParallel 里共享可变状态会测出锁竞争,这有时正是你想看的,但要清楚自己测的是无竞争读还是高竞争写,别把结论用错场景。
小结
- 基准函数写在
_test.go 里,BenchmarkXxx(b *testing.B),被测逻辑必须放在 b.N 循环内。
- 结果要落到包级变量,防止被编译器优化掉,否则数字全是假的。
- 数据准备放在循环外,之后调
ResetTimer();需要吞吐就调 SetBytes,需要内存指标就调 ReportAllocs。
- 日常命令:
go test -run '^$' -bench . -benchmem -count 5。
- 看四个数:ns/op、B/op、allocs/op、次数后缀里的 GOMAXPROCS。
- 有对比才有优化,用 benchstat 看 p 值,别信单次运行的百分之几。
- 规模差异用子基准
b.Run,并发能力用 b.RunParallel。