本篇内容介绍了“go怎么通过benchmark对代码进行性能测试”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！
benchmark的使用
在开发中我们要想编写高性能的代码，或者优化代码的性能时，你首先得知道当前代码的性能，在go中可以使用testing包的benchmark来做基准测试 ，首先我们写一个简单的返回随机字符串的方法
func randomStr(length int) string {
mathRand.Seed(time.Now().UnixNano())
letters := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
b := make([]byte, length)
for i := range b {
b[i] = letters[mathRand.Intn(len(letters))]
}
return string(b)
}要对上面的代码做基准测试，首先我们要新建一个测试文件，比如
main_test.go，然后新建一个基准测试方法
BenchmarkRandomStr，与普通的测试函数Test 开头，参数为t *testing.T类似，基准测试函数要以Benchmark开头，参数为b *testing.B，代码中的
b.N代表的是该用例的运行次数，这个值是会变的，对于每个用例都不一样，这个值会从1开始增加，具体的实现我会在下面的实现原理里进行介绍。
func BenchmarkRandomStr(b *testing.B) {
for i := 0; i < b.N; i++ {
randomStr(10000)
}
}运行Benchmark
我们可以使用
go test -bench .命令直接运行当前目录下的所有基准测试用例，-bench后面也可以跟正则或者是字符串来匹配对应的用例
$ go test -bench='Str$' goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-12 6692 181262 ns/op PASS ok learn/learn_test 2.142s
对上面的一些关键指标我们要了解一下，首先BenchmarkRandomStr-12后面的
-12代表的是
GOMAXPROCS这个跟你机器CPU的逻辑核数有关，在基准测试中可以通过
-cpu参数指定需要以几核的cpu来运行测试用例
$ go test -bench='Str$' -cpu=2,4,8 . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-2 6715 181197 ns/op BenchmarkRandomStr-4 6471 180249 ns/op BenchmarkRandomStr-8 6616 179510 ns/op PASS ok learn/learn_test 4.516s
6715和
181197 ns/op代表用例执行了6715次，每次花费的时间约为0.0001812s，总耗时约为1.2s（ns:s的换算为1000000000:1）
指定测试时长或测试次数
-benchtime=3s 指定时长
-benchtime=100000x 指定次数
-coun=3 指定轮数
$ go test -bench='Str$' -benchtime=3s . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-12 19988 177572 ns/op PASS ok learn/learn_test 5.384s $ go test -bench='Str$' -benchtime=10000x . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-12 10000 184832 ns/op PASS ok learn/learn_test 1.870s $ go test -bench='Str$' -count=2 . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-12 6702 177048 ns/op BenchmarkRandomStr-12 6482 177861 ns/op PASS ok learn/learn_test 3.269s
重置时间和暂停计时
有时候我们的测试用例会需要一些前置准备的耗时行为，这对我们的测试结果会产生影响，这个时候就需要在耗时操作后重置计时。下面我们用一个伪代码来模拟一下
func BenchmarkRandomStr(b *testing.B) {
time.Sleep(time.Second * 2) // 模拟耗时操作
for i := 0; i < b.N; i++ {
randomStr(10000)
}
}这时候我们再执行一下用例
$ go test -bench='Str$' . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-12 1 2001588866 ns/op PASS ok learn/learn_test 2.009s
发现只执行了一次，时间变成了2s多，这显然不符合我们的预期，这个时候需要调用
b.ResetTime()来重置时间
func BenchmarkRandomStr(b *testing.B) {
time.Sleep(time.Second * 2) // 模拟耗时操作
b.ResetTimer()
for i := 0; i < b.N; i++ {
randomStr(10000)
}
}再次执行基准测试
$ go test -bench='Str$' . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkRandomStr-12 6506 183098 ns/op PASS ok learn/learn_test 10.030s
运行次数和单次执行时间已经恢复到之前测试的情况了。基准测试还有
b.StopTimer()和
b.StartTimer()方法也是同样的道理，在影响耗时的操作之前停止计时，完成之后再开始计时。
查看内存使用情况
我们再评估代码的性能时，除了时间的快慢，还有一个重要的指标就是内存使用率，基准测试中可以通过
-benchmem来显示内存使用情况。下面我们用一组指定cap和不指定cap的返回int切片方法来看一下内存的使用情况
func getIntArr(n int) []int {
rand.Seed(uint64(time.Now().UnixNano()))
arr := make([]int, 0)
for i := 0; i < n; i++ {
arr = append(arr, rand.Int())
}
return arr
}
func getIntArrWithCap(n int) []int {
rand.Seed(uint64(time.Now().UnixNano()))
arr := make([]int, 0, n)
for i := 0; i < n; i++ {
arr = append(arr, rand.Int())
}
return arr
}
//------------------------------------------
// 基准测试代码
//------------------------------------------
func BenchmarkGetIntArr(b *testing.B) {
for i := 0; i < b.N; i++ {
getIntArr(100000)
}
}
func BenchmarkGetIntArrWithCap(b *testing.B) {
for i := 0; i < b.N; i++ {
getIntArrWithCap(100000)
}
}执行基准测试：
$ go test -bench='Arr' -benchmem . goos: darwin goarch: amd64 pkg: learn/learn_test cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz BenchmarkGetIntArr-12 598 1928991 ns/op 4101389 B/op 28 allocs/op BenchmarkGetIntArrWithCap-12 742 1556204 ns/op 802817 B/op 1 allocs/op PASS ok learn/learn_test 2.688s
可以看到指定了cap的方法执行的速度大约快20%，而内存的使用少了80%左右,
802817 B/op代表每次的内存使用情况，
1 allocs/op表示每次操作分配内存的次数
testing.B的底层实现
在写基准测试的时候，最让我搞不懂的是b.N的机制，如何根据不同的用例来自动调整执行的次数，然后我在源码中找到了一些蛛丝马迹。首先，先看一下基准测试的底层数据结构
type B struct {
common
importPath string
context *benchContext
N int // 这个就是要搞懂的N，代表要执行的次数
previousN int
previousDuration time.Duration
benchFunc func(b *B) // 测试函数
benchTime durationOrCountFlag // 执行时间，默认是1s 可以通过-benchtime指定
bytes int64
missingBytes bool
timerOn bool
showAllocResult bool
result BenchmarkResult
parallelism int
startAllocs uint64
startBytes uint64
netAllocs uint64
netBytes uint64
extra map[string]float64
}通过结构体中的N字段，可以找到几个关键的方法，
runN():每一次执行都会调用的方法，设置N的值。
run1():第一次迭代，根据它的结果决定是否需要运行更多的基准测试。
run(): run1()执行的结果为true的情况会调用，这个方法里调用
doBench()函数从而调用
launch()函数，这个是最终决定执行次数的函数
// Run benchmarks f as a subbenchmark with the given name. It reports
// whether there were any failures.
//
// A subbenchmark is like any other benchmark. A benchmark that calls Run at
// least once will not be measured itself and will be called once with N=1.
func (b *B) Run(name string, f func(b *B)) bool {
// ...省略部分代码
// Run()方法是基准测试的启动方法，会新建一个子测试
sub := &B{
common: common{
signal: make(chan bool),
name: benchName,
parent: &b.common,
level: b.level + 1,
creator: pc[:n],
w: b.w,
chatty: b.chatty,
bench: true,
},
importPath: b.importPath,
benchFunc: f,
benchTime: b.benchTime,
context: b.context,
}
// ...省略部分代码
if sub.run1() { // 执行一次子测试，如果不出错执行run()
sub.run() //最终调用 launch()方法，决定需要执行多少次runN()
}
b.add(sub.result)
return !sub.failed
}
// runN runs a single benchmark for the specified number of iterations.
func (b *B) runN(n int) {
// ....省略部分代码
b.N = n //指定N
// ...
}
// launch launches the benchmark function. It gradually increases the number
// of benchmark iterations until the benchmark runs for the requested benchtime.
// launch is run by the doBench function as a separate goroutine.
// run1 must have been called on b.
func (b *B) launch() {
// ....省略部分代码
d := b.benchTime.d
// 最少执行时间为1s,最多执行次数为1e9次
for n := int64(1); !b.failed && b.duration < d && n < 1e9; {
last := n
// 预测所需要的迭代次数
goalns := d.Nanoseconds()
prevIters := int64(b.N)
prevns := b.duration.Nanoseconds()
if prevns <= 0 {
//四舍五入，预防除0
prevns = 1
}
n = goalns * prevIters / prevns
// 避免增长的太快，先按1.2倍增长，最少增加一次
n += n / 5
n = min(n, 100*last)
n = max(n, last+1)
// 最多执行1e9次
n = min(n, 1e9)
b.runN(int(n))
}