Go语言基准测试：正确姿势与常见陷阱解析

func BenchmarkBubble(b *testing.B) {
    xs := generate(10000, -100, 100)
    SortBubble(xs) // 待测代码只执行了一次
}

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 函数用于生成随机整数切片。
// 注意：在实际基准测试中，为了结果的可重复性和避免性能开销，
// rand.Seed 通常只在程序启动时设置一次，或使用固定种子。
// 这里为了贴合原问题，沿用每次调用都播种的方式，但需注意其影响。
func generate(size int, min, max int) []int {
    rand.Seed(time.Now().UTC().UnixNano()) 
    xs := make([]int, size)
    for i := range xs {
        xs[i] = min + rand.Intn(max-min)
    }
    return xs
}

// makeCopy 辅助函数，用于创建切片的副本。
// 这对于会修改输入数据的基准测试至关重要，确保每次迭代都在原始数据副本上操作。
func makeCopy(src []int) []int {
    dst := make([]int, len(src))
    copy(dst, src)
    return dst
}

func BenchmarkBubble(b *testing.B) {
    // 1. 数据准备：在计时器重置前生成原始数据
    initialXs := generate(10000, -100, 100)

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

    // 3. 核心逻辑循环：在 b.N 次循环中执行待测代码
    for i := 0; i < b.N; i++ {
        // 4. 数据副本处理：每次迭代都对原始数据的副本进行排序
        // 确保测量的是对未排序数据的性能
        xs := makeCopy(initialXs)
        SortBubble(xs)
    }
}

func BenchmarkSelection(b *testing.B) {
    initialXs := generate(10000, -100, 100)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        xs := makeCopy(initialXs)
        SortSelection(xs)
    }
}

func BenchmarkInsertion(b *testing.B) {
    initialXs := generate(10000, -100, 100)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        xs := makeCopy(initialXs)
        SortInsertion(xs)
    }
}