CClara轻量论坛系统

Go 语言性能基准:benchmark 编写与结果分析

xiaoxin
xiaoxin 正式会员正式会员认证极客认证极客
发布于 2026-11-17 10:34 ·2 浏览 ·2 回复
内容摘要

讲解Go基准测试的规范写法与结果分析方法,包括用b.N循环和外部变量避免编译器优化、将准备数据移出计时区、用benchstat对比多次采样并以p值判断差异是否显著,以及按输入规模展开子基准和并行基准,从而识别真实性能提升与机器波动。

学完这篇,你能独立写出不含水分的 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 里共享可变状态会测出锁竞争,这有时正是你想看的,但要清楚自己测的是无竞争读还是高竞争写,别把结论用错场景。

小结

  1. 基准函数写在 _test.go 里,BenchmarkXxx(b *testing.B),被测逻辑必须放在 b.N 循环内。
  2. 结果要落到包级变量,防止被编译器优化掉,否则数字全是假的。
  3. 数据准备放在循环外,之后调 ResetTimer();需要吞吐就调 SetBytes,需要内存指标就调 ReportAllocs。
  4. 日常命令:go test -run '^$' -bench . -benchmem -count 5。
  5. 看四个数:ns/op、B/op、allocs/op、次数后缀里的 GOMAXPROCS。
  6. 有对比才有优化,用 benchstat 看 p 值,别信单次运行的百分之几。
  7. 规模差异用子基准 b.Run,并发能力用 b.RunParallel。
本文转载自 Clara轻量论坛系统,原文地址:https://www.leleweb.cn/thread-1188.html
转载请注明出处,版权归原作者所有。
—/ 5暂无评分
还没有评分,来打第一分吧

全部回复 2

Chilsion
Chilsion 正式会员正式会员认证极客认证极客 1楼 2026-11-17 10:42

你这套框架整体是对的,但第一段的 BenchmarkConcat 本身就踩了你后面讲的坑——"foo" + "bar" 是编译期常量折叠,运行时只剩一次赋值,测出来的是「写变量」而非「字符串拼接」的成本。想测真实拼接,至少让它依赖循环变量:sink = strings.Repeat("x", i%8) + "bar",或者干脆用 strings.Builder 做对照基准。

补完你截断的输出释义:BenchmarkParse-8 的 -8 是跑该基准时的 GOMAXPROCS;2000 是框架最终定下的 b.N;524288 ns/op 是单次迭代耗时;2.00 MB/s 由 SetBytes 换算得出;12 B/op、2 allocs/op 是每次迭代的堆分配字节与次数。

至于「真有提升还是机器在抖」,单看一行 ns/op 没意义,-count 5 的意义就是喂给 benchstat old.txt new.txt:它给几何平均值、变异系数和 p 值,只有 p < 0.05 且中位数差距稳定才算数。自己肉眼比时,两轮差距小于 5% 基本可以当噪声处理。

另外两个常被忽略的点:一是 allocs/op 往往比 ns/op 更值得盯,分配次数降下来后 GC 压力带来的收益在真实负载里比微基准更明显;二是跑基准前记得固定 CPU 频率、关掉其它负载,否则 -cpu=1,2,4 那组并发扩展性数据会很飘。

djsens
djsens 见习用户见习用户 #2674 2楼 2026-11-17 10:47
Chilsion:你这套框架整体是对的,但第一段的 `BenchmarkConcat` 本身就踩了你后面讲的坑——`"foo" + "bar"` 是编译期常量折叠,运行时只剩一次…

Chilsion 这条补充我基本照单全收,尤其第一点——我那个 BenchmarkConcat 等于自己踩自己挖的坑,得改。

常量折叠这块没得辩:"foo" + "bar" 编译期就折叠成 "foobar",循环体退化成一次 string header 赋值,0.3 ns/op 是写两个 word 的成本,跟拼接毫无关系。不过你给的 strings.Repeat("x", i%8) + "bar" 我也不太推荐——Repeat 自己带分配、i%8 也是额外运算,两笔开销都会算进 ns/op,而且输入规模随 i 变,b.N 一放大负载就漂了。更干净的是预置候选切片,循环里只做 sink = ss[i&7] + "bar";要正经做对比就走 b.Run 子基准,把 +、fmt.Sprintf、strings.Builder、strings.Join 摆一组,这也是官方 wiki 的路子。

benchstat 我补两点:一是两边 bench 名和 -cpu 集合必须一致才配得上对,否则会被当成不同基准各算各的;二是 -count 5 的样本量做 UTest 功效一般,要下定论建议 -count 10,3~5% 的差距直接归为噪声。

allocs/op 优先于 ns/op 完全同意,再补一手 b.ReportMetric 能把 GC 次数之类自定义指标塞进输出,benchstat 也认。固定频率那条是硬要求,-cpu=1,2,4 在降频的笔记本上基本没法看。

一个延伸的坑:基准里任何依赖 i 的输入构造都会让不同 b.N 下的负载不一致,结果不可比——宁可多花点准备时间,用 b.ResetTimer 前把数据备齐。