Go 语言性能测试：Benchmark 入门指南 – wiki基地

作者： /

Go 语言性能测试：Benchmark 入门指南

在软件开发中，性能是衡量一个系统质量的关键指标之一。一个高性能的应用程序能够提供更好的用户体验、降低运行成本、提高资源利用率，并在高负载下保持稳定。Go 语言以其优秀的并发特性和接近 C 的执行效率而闻名，但即使是 Go，也需要开发者关注代码的性能。

性能测试是评估代码执行效率的手段。它帮助我们了解代码在特定条件下的运行速度、资源消耗（如内存分配），并识别性能瓶颈。在 Go 语言中，标准库提供了一个强大且易用的内置工具来执行性能测试，即 testing 包中的 Benchmark 功能。

本文将带你深入了解 Go 语言的 Benchmark 工具，从基础用法到进阶技巧，帮助你写出有效的性能测试代码，并解读测试结果。

第一章：为什么需要进行性能测试？

在深入了解如何进行性能测试之前，我们先来明确一下为什么它如此重要：

  1. 量化改进效果： 当你对代码进行优化时，Benchmark 可以提供客观的数据来证明你的改动是否真的带来了性能提升。感觉快不等于真的快。
  2. 发现性能瓶颈： 代码中的某些部分可能比预期的要慢得多。通过 Benchmark，你可以精确地定位这些“热点”代码，从而集中精力进行优化。
  3. 比较不同实现方案： 对于同一个功能，往往存在多种实现方式。Benchmark 可以帮助你量化比较不同方案的性能差异，选择最优解。
  4. 避免性能回归： 将 Benchmark 集成到持续集成 (CI) 流程中，可以在代码提交时自动运行性能测试，及时发现可能导致性能下降的改动。
  5. 预测系统能力： 通过对关键组件进行 Benchmark，可以估算出系统在高负载下的处理能力，为容量规划提供数据支持。
  6. 理解语言特性： 某些语言特性或库函数的使用方式可能对性能产生显著影响。Benchmark 可以帮助你更深入地理解这些影响。

切记，不要过早优化（Premature Optimization）。应该先写出正确、清晰的代码，然后在有性能需求或发现瓶颈时，再进行性能测试和优化。Benchmark 应该作为优化过程中的有力工具，而不是起点。

第二章：Go 内建 Benchmark 工具概览

Go 语言的 Benchmark 工具集成在标准的 testing 包中，与单元测试和示例测试共存于同一个框架下。这意味着你不需要引入第三方库，只需遵循一些简单的约定即可开始编写性能测试。

核心概念：

  • 测试文件： Benchmark 函数通常与对应的代码放在同一个目录下，文件后缀为 _test.go。
  • 函数签名： Benchmark 函数必须以 Benchmark 开头，接收一个类型为 *testing.B 的参数，且没有返回值。例如：func BenchmarkMyFunction(b *testing.B)。
  • *testing.B 类型： 这个类型提供了控制 Benchmark 行为和记录性能数据的方法。最重要的是 b.N 字段，它表示 Benchmark 需要运行的次数。
  • 核心循环： Benchmark 函数的核心逻辑通常在一个 for i := 0; i < b.N; i++ 循环中执行，你需要将要测试的代码放在这个循环内部。

Go 的测试工具（go test 命令）会自动发现并运行符合命名约定的 Benchmark 函数。它会通过调整 b.N 的值，尝试找到一个合适的迭代次数，使得 Benchmark 的总执行时间足够长（默认至少 1 秒），以便获得稳定可靠的测量结果。

第三章：编写你的第一个 Benchmark

让我们通过一个简单的例子来学习如何编写 Benchmark。假设我们有两个函数，一个用于计算斐波那契数列的第 n 个数，另一个是它的优化版本（使用迭代或记忆化）。我们想比较它们的性能。

首先，我们创建两个函数：

“`go
// fib.go
package main

import “fmt”

// RecursiveFib 是一个递归实现的斐波那契数列函数
func RecursiveFib(n int) int {
if n <= 1 {
return n
}
return RecursiveFib(n-1) + RecursiveFib(n-2)
}

// IterativeFib 是一个迭代实现的斐波那契数列函数
func IterativeFib(n int) int {
if n <= 1 {
return n
}
a, b := 0, 1
for i := 2; i <= n; i++ {
a, b = b, a+b
}
return b
}

// 为了让 Benchmark 能够运行，需要一个 main 包或被其他包引入
func main() {
// 可以在这里放置一些测试代码，但 Benchmark 运行时不执行 main
fmt.Println(“RecursiveFib(10):”, RecursiveFib(10))
fmt.Println(“IterativeFib(10):”, IterativeFib(10))
}
“`

接下来，我们在 同一个目录下 创建一个名为 fib_test.go 的文件，并在其中编写 Benchmark 函数：

“`go
// fib_test.go
package main

import “testing”

// BenchmarkRecursiveFib 对 RecursiveFib 函数进行性能测试
func BenchmarkRecursiveFib(b *testing.B) {
// b.N 是由测试框架动态调整的迭代次数
for i := 0; i < b.N; i++ {
// 在循环内调用要测试的函数
RecursiveFib(20) // 选择一个适当的输入，使其有足够的计算量
}
}

// BenchmarkIterativeFib 对 IterativeFib 函数进行性能测试
func BenchmarkIterativeFib(b *testing.B) {
// b.N 是由测试框架动态调整的迭代次数
for i := 0; i < b.N; i++ {
// 在循环内调用要测试的函数
IterativeFib(20) // 使用与 RecursiveFib 相同的输入
}
}
“`

代码解释：

  1. package main: Benchmark 文件需要与被测试的代码处于同一个包。
  2. import "testing": 导入 Go 的测试包。
  3. func BenchmarkRecursiveFib(b *testing.B): 定义一个 Benchmark 函数。函数名必须以 Benchmark 开头，参数为 *testing.B。
  4. for i := 0; i < b.N; i++: 这是 Benchmark 的核心循环。测试框架会根据函数的执行时间自动确定 b.N 的值。b.N 会从一个较小的值开始（比如 1），如果总执行时间不足 1 秒，b.N 会成倍增加，直到总时间超过 1 秒或 b.N 达到某个上限。
  5. RecursiveFib(20) / IterativeFib(20): 将需要测试性能的代码放在循环内部。选择输入 20 是为了让 RecursiveFib 有足够的计算量（递归版本对于较大的 n 会变得非常慢），这样 Benchmark 才能更准确地测量其性能。对于 IterativeFib，即使是 20 也非常快，但为了公平比较，我们使用相同的输入。

第四章：运行 Benchmark

编写好 Benchmark 文件后，就可以使用 go test 命令来运行它了。

在终端中，切换到 fib.go 和 fib_test.go 所在的目录，然后执行以下命令：

bash
go test -bench=.

命令解释：

  • go test: Go 语言的标准测试命令。
  • -bench: 这个标志告诉 go test 运行 Benchmark 测试。
  • .: 这是一个正则表达式，表示运行所有 Benchmark 函数。如果你只想运行特定的 Benchmark，可以使用更精确的正则表达式，例如 -bench=Recursive 只运行 BenchmarkRecursiveFib。

执行命令后，你将看到类似以下的输出（具体数字会因机器性能而异）：

goos: linux
goarch: amd64
pkg: your_module_path/your_package_name # 你的模块路径/包名
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkRecursiveFib-12 23260 48531 ns/op
BenchmarkIterativeFib-12 2000000000 0.33 ns/op
PASS
ok your_module_path/your_package_name 2.543s

注意： 如果你的 Go 文件属于一个模块（使用了 go mod init），你需要确保在模块的根目录或子目录中运行 go test。输出中的 pkg 会显示你的模块路径。如果是非模块项目或在 GOPATH 模式下，pkg 可能是点号 .。

第五章：解读 Benchmark 输出

理解 Benchmark 的输出非常重要。让我们来分解上面的输出行：

BenchmarkRecursiveFib-12 23260 48531 ns/op

  • BenchmarkRecursiveFib: Benchmark 函数的名称。
  • -12: 表示 Benchmark 是在有 12 个 CPU 核心可用时运行的。go test 默认会使用机器的逻辑核心数。你可以使用 -cpu 标志来指定不同的核心数，例如 -cpu=1,4,8 会在单核、4核和8核环境下分别运行 Benchmark。
  • 23260: 这是 b.N 的最终值，表示 Benchmark 函数体内的循环总共执行了 23260 次。测试框架通过动态调整 b.N 达到了预设的最小执行时间（通常是 1 秒）。
  • 48531 ns/op: 这是最重要的指标。它表示每次操作（即循环体内的一次执行）的平均耗时，单位是纳秒 (ns)。在这个例子中，递归计算 RecursiveFib(20) 平均需要 48531 纳秒，也就是 48.531 微秒。

再看下一行：

BenchmarkIterativeFib-12 2000000000 0.33 ns/op

  • BenchmarkIterativeFib-12: 迭代实现的 Benchmark 名称和 CPU 核心数。
  • 2000000000: b.N 的最终值达到了 20 亿次！这是因为迭代实现非常快，测试框架需要运行很多次才能达到 1 秒的总执行时间。
  • 0.33 ns/op: 每次操作平均耗时 0.33 纳秒。

结论： 对比 48531 ns/op 和 0.33 ns/op，可以清晰地看出迭代实现的斐波那契函数比递归实现（对于 n=20）要快得多，快了约 14 万倍！这印证了我们的预期：递归在没有记忆化的情况下计算斐波那契数列效率低下。

总而言之，你需要关注的是 X ns/op 这个值，它直接反映了你的代码每次执行的平均速度。越小越好。

第六章：Benchmark 编写进阶与最佳实践

编写有效的 Benchmark 需要注意一些细节，以确保结果的准确性和可靠性。

6.1 避免不必要的开销：Setup 和 Teardown

Benchmark 的目的是测量核心代码的性能，而不是准备数据或清理环境的开销。如果你的 Benchmark 需要在循环开始前进行一些一次性的设置工作，可以使用 b.ResetTimer() 方法来重置计时器。

“`go
func BenchmarkWithSetup(b *testing.B) {
// — Setup code (runs once before the loop) —
largeSlice := make([]int, 10000)
for i := range largeSlice {
largeSlice[i] = i
}
// — Setup code end —

// ResetTimer() 之后才会开始计时
b.ResetTimer()

// Core Benchmark loop
for i := 0; i < b.N; i++ {
    // 要测试的代码
    _ = largeSlice[i%len(largeSlice)] // 模拟对切片的访问
}

// 可选：使用 b.StopTimer() 和 b.StartTimer() 暂停/恢复计时
// b.StopTimer() // 如果循环内有不需要计时的操作（比如打印日志）
// time.Sleep(10 * time.Millisecond) // 例如模拟等待
// b.StartTimer() // 恢复计时

}
“`

b.ResetTimer() 会停止当前的计时器，并清零已记录的时间和内存分配计数。之后在 b.N 循环中执行的代码才会重新开始计时和计数。

6.2 防止编译器优化掉你的代码

Go 编译器可能会进行一些优化，例如如果一个计算结果没有被使用，编译器可能会直接将其优化掉，导致 Benchmark 测量的是空循环的速度，而不是实际计算的速度。

为了避免这种情况，你应该确保循环的计算结果被以某种方式使用到。常见的做法是将结果赋给一个全局变量或结构体字段，或者在循环后返回结果（尽管 Benchmark 函数签名不允许返回值，但可以通过其他方式，比如赋值给测试结构体的字段）。更常见且简单的做法是使用 testing.B.ReportAllocs() 或 -benchmem 标志来强制编译器保留可能涉及内存分配的代码，这通常也足以防止简单的计算被优化掉。

例如，如果我们测试一个简单的加法：

go
// 可能被优化的 Benchmark
func BenchmarkAdd(b *testing.B) {
var sum int
for i := 0; i < b.N; i++ {
sum = 1 + 2 // 这里的 sum 可能在循环外计算一次就被优化
}
// sum 没被使用，编译器可能认为整个循环是无用的
}

更安全的方式是：

“`go
// 避免被优化的 Benchmark
var result int // 使用全局变量

func BenchmarkAddSafe(b *testing.B) {
for i := 0; i < b.N; i++ {
result = 1 + 2 // 将结果赋给全局变量
}
}
“`

或者，如果测试的函数本身有返回值，确保在循环中调用它并对返回值进行操作：

“`go
func add(a, b int) int { return a + b }

var globalInt int // 或者使用其他方式来消耗结果

func BenchmarkAddFunc(b *testing.B) {
var res int
for i := 0; i < b.N; i++ {
res = add(i, i+1) // 调用函数并将结果赋给局部变量
}
globalInt = res // 在循环结束后将最后一个结果赋给全局变量
}
“`

对于像我们之前的斐波那契例子，函数本身有返回值，并且我们在循环中调用了它。虽然没有将结果赋给全局变量，但在实际使用中，对于有副作用或有返回值的函数，Go 编译器通常不会完全优化掉函数调用本身。然而，最佳实践是确保计算结果以某种方式被使用，以防万一。对于只进行计算并返回结果的函数，将结果赋给一个局部变量并在循环后赋给一个包级变量是常见的做法。

6.3 避免 I/O 和外部依赖

Benchmark 应该尽可能地隔离和稳定。避免在 Benchmark 循环内进行文件读写、网络请求、数据库访问等 I/O 操作或依赖外部服务。这些操作通常耗时且不稳定，会极大地干扰性能测量结果。

如果你的代码依赖外部资源，你应该考虑：

  • 模拟 (Mocking)： 使用 mock 对象或内存中的数据结构来替代外部依赖。
  • 在 Setup 中准备： 如果某些依赖可以一次性加载到内存中，可以在 b.ResetTimer() 之前完成。

6.4 理解 b.N 和循环展开

如前所述，b.N 的值是由测试框架动态决定的。你不需要担心 b.N 太小导致测量不准确。Go 的测试框架会自动运行 Benchmark 足够多次（或足够长时间）来获得稳定结果。

你也不需要在 Benchmark 函数体内的循环中手动进行“循环展开”（Loop Unrolling），例如将代码块复制多次以减少循环控制的开销。Go 的测试框架在执行 Benchmark 时，可能会在底层进行优化，它会根据函数执行时间调整 b.N，并在需要时进行某种形式的循环展开，以更精确地测量每次操作的耗时。你只需要编写简单的 for i := 0; i < b.N; i++ 循环即可。

第七章：子 Benchmark (Sub-benchmarks)

当你想对同一个函数的不同参数、不同状态或不同场景进行 Benchmark 时，可以使用子 Benchmark (b.Run)。这有助于组织你的测试，并在运行 Benchmark 时选择性地运行特定场景。

子 Benchmark 函数的签名与普通的 Benchmark 函数类似，但它们作为参数传递给 b.Run() 方法。

“`go
// sub_benchmark_example_test.go
package main

import (
“strconv”
“testing”
)

func performWork(size int) []byte {
// 模拟根据 size 进行一些工作，例如创建一个指定大小的切片
return make([]byte, size)
}

func BenchmarkPerformWork(b testing.B) {
// 使用 b.Run 定义子 Benchmark
b.Run(“Size10”, func(b testing.B) {
for i := 0; i < b.N; i++ {
performWork(10)
}
})

b.Run("Size100", func(b *testing.B) {
    for i := 0; i < b.N; i++ {
        performWork(100)
    }
})

b.Run("Size1000", func(b *testing.B) {
    for i := 0; i < b.N; i++ {
        performWork(1000)
    }
})

}

// 或者更动态地创建子 Benchmark (例如使用参数)
func BenchmarkPerformWorkDynamic(b testing.B) {
sizes := []int{10, 100, 1000, 10000}
for _, size := range sizes {
// 使用 b.Run 定义子 Benchmark，名称中包含参数值
b.Run(“Size”+strconv.Itoa(size), func(b testing.B) {
b.ReportAllocs() // 可以在子 Benchmark 中单独开启内存分配报告
for i := 0; i < b.N; i++ {
performWork(size)
}
})
}
}
“`

运行子 Benchmark：

bash
go test -bench=. -benchmem

输出可能如下：

goos: linux
goarch: amd64
pkg: your_module_path/your_package_name
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkPerformWork/Size10-12 2000000000 0.35 ns/op
BenchmarkPerformWork/Size100-12 124078140 9.60 ns/op
BenchmarkPerformWork/Size1000-12 1332381 868.5 ns/op
BenchmarkPerformWorkDynamic/Size10-12 2000000000 0.35 ns/op 0 B/op 0 allocs/op
BenchmarkPerformWorkDynamic/Size100-12 123898870 9.65 ns/op 100 B/op 1 allocs/op
BenchmarkPerformWorkDynamic/Size1000-12 1323130 878.8 ns/op 1000 B/op 1 allocs/op
BenchmarkPerformWorkDynamic/Size10000-12 131029 8702 ns/op 10000 B/op 1 allocs/op
PASS
ok your_module_path/your_package_name 5.678s

可以看到，子 Benchmark 的名称会显示为 父Benchmark名称/子Benchmark名称。使用 -bench=. 会运行所有顶层 Benchmark 和子 Benchmark。你可以通过更精确的正则表达式来运行特定的子 Benchmark，例如 go test -bench=Size100$ 只运行所有名称以 “Size100” 结尾的 Benchmark。

第八章：Benchmark 与内存分析 (-benchmem)

除了测量执行时间，Go 的 Benchmark 工具还可以报告内存分配情况。这对于识别代码中的内存分配热点和减少垃圾回收 (GC) 压力非常有用。

使用 -benchmem 标志可以开启内存分配报告：

bash
go test -bench=. -benchmem

输出会增加两列：B/op (Bytes per operation) 和 allocs/op (allocations per operation)。

我们来比较一下 Go 中两种常见的字符串拼接方式：使用 + 运算符和使用 strings.Builder。

“`go
// string_concat_test.go
package main

import (
“strings”
“testing”
)

func benchmarkConcat(n int, b *testing.B) {
var s string
for i := 0; i < b.N; i++ {
s += “x” // 在循环内拼接字符串 n 次
}
}

func benchmarkBuilder(n int, b *testing.B) {
var sb strings.Builder
for i := 0; i < b.N; i++ {
sb.WriteString(“x”) // 在循环内使用 Builder 拼接
}
_ = sb.String() // 需要调用 String() 来获取最终字符串，这通常在循环外一次性完成
}

func BenchmarkStringConcat(b *testing.B) {
// 在 Benchmark 函数内调用实际测试逻辑，将 b.N 传递给它
benchmarkConcat(100, b) // 拼接 100 次
}

func BenchmarkStringBuilder(b *testing.B) {
benchmarkBuilder(100, b) // 拼接 100 次
}
“`

运行 go test -bench=. -benchmem：

goos: linux
goarch: amd64
pkg: your_module_path/your_package_name
cpu: Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz
BenchmarkStringConcat-12 289023 4078 ns/op 1040 B/op 100 allocs/op
BenchmarkStringBuilder-12 2000000000 0.33 ns/op 0 B/op 0 allocs/op
PASS
ok your_module_path/your_package_name 3.456s

解读内存输出：

  • BenchmarkStringConcat-12: 4078 ns/op（每次操作 4078 纳秒）、1040 B/op（每次操作分配 1040 字节）、100 allocs/op（每次操作发生 100 次内存分配）。
  • BenchmarkStringBuilder-12: 0.33 ns/op（每次操作 0.33 纳秒）、0 B/op（每次操作分配 0 字节）、0 allocs/op（每次操作发生 0 次内存分配）。

结论： 当我们使用 + 运算符在循环中反复拼接字符串时，Go 会创建很多新的字符串对象。每次 s += "x" 都会创建一个新的字符串，将 s 原来的内容和 "x" 复制进去。这意味着拼接 100 次，就会发生大约 100 次内存分配。这不仅耗时，还会给垃圾回收器带来很大压力。

而 strings.Builder 使用一个可增长的缓冲区，大多数写操作都直接写入这个缓冲区，避免了频繁的内存分配和复制。最终调用 String() 时才可能发生一次分配（如果需要）。因此，strings.Builder 在循环中拼接大量字符串的场景下，性能和内存效率都远超 + 运算符。

注意： 在上面的例子中，benchmarkConcat 和 benchmarkBuilder 函数本身才是实际被 Benchmark 的逻辑。BenchmarkStringConcat 和 BenchmarkStringBuilder 函数只是一个包装，将 b.N 传递给实际逻辑函数。这种模式也很常见，有助于将 Benchmark 逻辑与实际被测函数分离开。

第九章：忽略 Benchmark

有时候你可能不想运行所有的 Benchmark，或者想暂时禁用某个 Benchmark。

  • 修改函数名： 将函数名从 BenchmarkXxx 改为 Benchmark_Xxx (在 Benchmark 后面加下划线)。go test 默认不会运行带下划线的 Benchmark 函数。
  • 使用 b.SkipNow()： 在 Benchmark 函数内部调用 b.SkipNow() 可以跳过当前的 Benchmark。这通常用于某些前置条件不满足时。

go
func BenchmarkShouldSkip(b *testing.B) {
if someConditionIsNotMet { // 例如，检查是否有外部依赖
b.SkipNow() // 跳过这个 Benchmark
}
// 正常 Benchmark 逻辑
for i := 0; i < b.N; i++ {
// ...
}
}

第十章：将 Benchmark 与 Profiling 结合

Benchmark 告诉你代码“有多快”以及“分配了多少内存”，而 Profiling（性能分析）则告诉你“时间花在哪里了”以及“内存分配在哪里发生的”。将 Benchmark 与 Profiling 结合使用是定位和解决性能问题的强大组合。

go test 命令提供了一些标志，可以在运行 Benchmark 的同时生成 Profile 文件：

  • -cpuprofile cpu.prof: 生成 CPU Profile 文件。
  • -memprofile mem.prof: 生成 Memory Profile 文件。

例如：

bash
go test -bench=. -benchmem -cpuprofile cpu.prof -memprofile mem.prof

运行完成后，会在当前目录下生成 cpu.prof 和 mem.prof 文件。然后，你可以使用 go tool pprof 命令来分析这些文件：

bash
go tool pprof cpu.prof

进入 pprof 交互界面后，可以使用 top 查看最耗时的函数，使用 list 函数名 查看特定函数的代码行耗时，使用 web 生成可视化图表（需要安装 Graphviz）。

虽然 Profiling 本身是一个复杂的话题，超出了本入门指南的范围，但了解如何在 Benchmark 中生成 Profile 文件是迈向深入性能优化的重要一步。

结论

Go 语言内置的 Benchmark 工具是性能测试的强大而便捷的武器。通过本文的学习，你应该已经掌握了：

  • 编写基本 Benchmark 函数的结构和约定。
  • 使用 go test -bench 运行 Benchmark。
  • 解读 Benchmark 输出，理解 ns/op 的含义。
  • 使用 b.ResetTimer() 隔离 Setup 代码。
  • 使用 -benchmem 报告和分析内存分配。
  • 使用 b.Run() 创建子 Benchmark。
  • 了解编写有效 Benchmark 的最佳实践（避免 I/O，防止优化）。
  • 如何将 Benchmark 与 Profiling 结合使用。

性能优化是一个迭代的过程。先进行 Benchmark，找出瓶颈，然后使用 Profiling 定位具体问题，进行代码优化，最后再次运行 Benchmark 来验证优化效果。通过不断实践和测量，你将能够写出更高性能、更资源高效的 Go 代码。现在，开始写你的第一个 Benchmark 并探索你的代码性能吧！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部