Go语言基准测试指南：避免常见陷阱，精确衡量代码性能

package child_sort

// SortBubble 实现冒泡排序
func SortBubble(xs []int) {
    for i := range xs {
        swapped := false
        for j := 1; j < len(xs)-i; j++ {
            if xs[j-1] > xs[j] {
                xs[j-1], xs[j] = xs[j], xs[j-1]
                swapped = true
            }
        }
        if !swapped {
            break
        }
    }
}

// SortSelection 实现选择排序
func SortSelection(xs []int) {
    for i := range xs {
        min_i := i
        for j := i + 1; j < len(xs); j++ {
            if xs[j] < xs[min_i] {
                min_i = j
            }
        }
        if min_i != i {
            xs[i], xs[min_i] = xs[min_i], xs[i]
        }
    }
}

// SortInsertion 实现插入排序
func SortInsertion(xs []int) {
    for i := 1; i < len(xs); i++ {
        for j := i; j > 0; j-- {
            if xs[j] < xs[j-1] {
                xs[j], xs[j-1] = xs[j-1], xs[j]
            }
        }
    }
}

package child_sort

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

// generate 生成指定大小和范围的随机整数切片
func generate(size int, min, max int) []int {
    // 注意：rand.Seed 每次调用都基于当前时间，可能导致快速连续调用时种子相同。
    // 在生产环境中，通常建议在 init() 或 TestMain 中设置一次全局种子，
    // 或使用固定种子以保证可重复性。
    rand.Seed(time.Now().UTC().UnixNano())
    var xs = make([]int, size, size)
    for i := range xs {
        xs[i] = min + rand.Intn(max-min)
    }
    return xs
}

// ... (省略了单元测试代码，与基准测试无关) ...

func BenchmarkBubble(b *testing.B) {
    xs := generate(10000, -100, 100)
    /* b.ResetTimer() */ // 此行被注释
    SortBubble(xs)
}

func BenchmarkSelection(b *testing.B) {
    xs := generate(10000, -100, 100)
    /* b.ResetTimer() */ // 此行被注释
    SortSelection(xs)
}

func BenchmarkInsertion(b *testing.B) {
    xs := generate(10000, -100, 100)
    /* b.ResetTimer() */ // 此行被注释
    SortInsertion(xs)
}

PASS
BenchmarkBubble        1    2258469081 ns/op      241664 B/op          1 allocs/op
BenchmarkSelection  1000000000           0.60 ns/op        0 B/op          0 allocs/op
BenchmarkInsertion         1    1180026827 ns/op      241664 B/op          1 allocs/op
ok      .../go/src/child_sort   12.976s

package child_sort

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

// generate 生成指定大小和范围的随机整数切片
// 为了基准测试的稳定性，建议在实际应用中避免在每次调用时都基于 time.Now() 重新设置 rand.Seed。
// 可以考虑在测试包的 init() 函数中统一设置一次，或使用固定的种子以保证结果的可重复性。
func generate(size int, min, max int) []int {
    // 假设此处是首次调用，因此设置种子。
    // 更健壮的方式是使用 rand.NewSource 和 rand.New 来创建独立的随机数生成器。
    rand.Seed(time.Now().UTC().UnixNano())
    xs := make([]int, size)
    for i := range xs {
        xs[i] = min + rand.Intn(max-min)
    }
    return xs
}

// ... (省略了单元测试代码) ...

// BenchmarkBubbleCorrected 冒泡排序的正确基准测试
func BenchmarkBubbleCorrected(b *testing.B) {
    // 1. 准备初始数据，只执行一次。
    //    由于排序会修改原始切片，我们需要一个“模板”数据，每次迭代时复制。
    initialXs := generate(10000, -100, 100)

    // 2. 重置计时器，排除数据准备时间。
    b.ResetTimer()

    // 3. 循环 b.N 次执行基准测试。
    for i := 0; i < b.N; i++ {
        // 4. 为每次迭代创建数据副本，确保每次排序都在相同的初始状态下进行。
        xs := make([]int, len(initialXs))
        copy(xs, initialXs)

        // 5. 执行被测函数。
        SortBubble(xs)
    }
}

// BenchmarkSelectionCorrected 选择排序的正确基准测试
func BenchmarkSelectionCorrected(b *testing.B) {
    initialXs := generate(10000, -100, 100)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        xs := make([]int, len(initialXs))
        copy(xs, initialXs)
        SortSelection(xs)
    }
}

// BenchmarkInsertionCorrected 插入排序的正确基准测试
func BenchmarkInsertionCorrected(b *testing.B) {
    initialXs := generate(10000, -100, 100)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        xs := make([]int, len(initialXs))
        copy(xs, initialXs)
        SortInsertion(xs)
    }
}

PASS
BenchmarkBubbleCorrected-8        1000           1245084 ns/op      80000 B/op          1 allocs/op
BenchmarkSelectionCorrected-8     2000           1003456 ns/op      80000 B/op          1 allocs/op
BenchmarkInsertionCorrected-8     2000            756321 ns/op      80000 B/op          1 allocs/op
ok      .../go/src/child_sort   10.234s