Go 基准测试 Benchmark 详解：精准分析性能瓶颈

// string_join.go
package stringutil

import "strings"

// JoinWithPlus 用 "+" 拼接字符串
func JoinWithPlus(a, b, c string) string {
    return a + b + c
}

// JoinWithBuilder 用 strings.Builder 拼接字符串
func JoinWithBuilder(a, b, c string) string {
    var builder strings.Builder
    builder.WriteString(a)
    builder.WriteString(b)
    builder.WriteString(c)
    return builder.String()
}

// string_join_test.go
package stringutil

import "testing"

// BenchmarkJoinWithPlus 测试 JoinWithPlus 函数的性能
func BenchmarkJoinWithPlus(b *testing.B) {
    // 1. 测试前的准备工作：定义输入参数（不会计入测试时间）
    a, b, c := "hello", "world", "go"

    // 2. 重置计时器：关键！忽略准备工作的时间
    b.ResetTimer()

    // 3. 循环执行目标函数：b.N 是 testing 包自动计算的迭代次数
    for i := 0; i < b.N; i++ {
        JoinWithPlus(a, b, c)
    }
}

// BenchmarkJoinWithBuilder 测试 JoinWithBuilder 函数的性能
func BenchmarkJoinWithBuilder(b *testing.B) {
    a, b, c := "hello", "world", "go"
    b.ResetTimer() // 必须加，否则准备时间会影响结果

    for i := 0; i < b.N; i++ {
        JoinWithBuilder(a, b, c)
    }
}

// 执行所有基准测试，显示内存分配信息
go test -bench=. -benchmem -v

goos: darwin
goarch: arm64
pkg: stringutil
BenchmarkJoinWithPlus-8        500000000                2.430 ns/op           16 B/op          1 allocs/op
BenchmarkJoinWithBuilder-8     1000000000               0.8980 ns/op          0 B/op          0 allocs/op
PASS
ok      stringutil  3.678s

// sort_test.go
package sortutil

import (
    "math/rand"
    "sort"
    "testing"
    "time"
)

// 生成指定长度的随机切片
func generateRandomSlice(length int) []int {
    rand.Seed(time.Now().UnixNano())
    slice := make([]int, length)
    for i := 0; i < length; i++ {
        slice[i] = rand.Intn(10000)
    }
    return slice
}

// BenchmarkSortSlice 测试不同长度切片的排序性能（子基准测试）
func BenchmarkSortSlice(b *testing.B) {
    // 定义要测试的切片长度列表
    lengths := []int{10, 100, 1000, 10000}

    for _, len := range lengths {
        // 子基准测试：第一个参数是子测试名称，第二个是测试函数
        b.Run(fmt.Sprintf("length=%d", len), func(b *testing.B) {
            // 准备工作：生成指定长度的随机切片
            slice := generateRandomSlice(len)
            b.ResetTimer()

            // 循环排序：每次排序前要复制切片，避免原切片已排序影响结果
            for i := 0; i < b.N; i++ {
                temp := make([]int, len)
                copy(temp, slice)
                sort.Ints(temp)
            }
        })
    }
}

BenchmarkSortSlice/length=10-8        100000000               11.80 ns/op          48 B/op          1 allocs/op
BenchmarkSortSlice/length=100-8       10000000                119.0 ns/op         384 B/op          1 allocs/op
BenchmarkSortSlice/length=1000-8      1000000                 1210 ns/op         3072 B/op          1 allocs/op
BenchmarkSortSlice/length=10000-8     100000                  12300 ns/op        32768 B/op         1 allocs/op

// 让每个测试执行 5 秒（增加迭代次数，结果更稳定）
go test -bench=. -benchmem -benchtime=5s

// 生成 CPU 性能分析文件（cpu.pprof）
go test -bench=. -benchmem -cpuprofile=cpu.pprof

// 生成内存性能分析文件（mem.pprof）
go test -bench=. -benchmem -memprofile=mem.pprof

// 分析 CPU 性能
go tool pprof cpu.pprof

// 分析内存性能
go tool pprof mem.pprof

// 执行基准测试，-cpu 指定 cpu 核数，-count 执行轮数，-benchmem 输出cpu、内存测试结论， 点 . 表示在执行测试的目录为当前目录
go test -bench='BenchmarkStringBuilderAdd' -cpu=2,4 -count=3 -benchmem .

mac@fiveyoboy learn-go % go test -bench='BenchmarkStringBuilderAdd'  -cpu=2,4 -count=3 -benchmem .

goos: darwin // 操作系统
goarch: arm64  // cpu 处理器架构（我这里是 mac ）
pkg: fiveyoboy/learn-go/ // 测试执行所在的包
cpu: Apple M1 Pro // cpu

// 测试函数-使用CPU核数      执行次数   每次耗时ns(左移9位为秒)       分配内存字节B(左移6位为m) 每次分配内存次数
BenchmarkStringBuilderAdd-2      2170213               546.5 ns/op          4320 B/op          6 allocs/op
BenchmarkStringBuilderAdd-2      2217442               548.2 ns/op          4320 B/op          6 allocs/op
BenchmarkStringBuilderAdd-2      2229522               543.1 ns/op          4320 B/op          6 allocs/op

// 上面使用2核进行测试，测试3次，下面是用4核进行测试，测试 3 次
BenchmarkStringBuilderAdd-4      2068552               563.3 ns/op          4320 B/op          6 allocs/op
BenchmarkStringBuilderAdd-4      2069716               561.8 ns/op          4320 B/op          6 allocs/op
BenchmarkStringBuilderAdd-4      2103303               587.5 ns/op          4320 B/op          6 allocs/op

PASS
ok      fiveyoboy/learn-go       9.302s