第9章性能分析

# 第9章性能分析

在本章中，我们将深入探讨Go编程语言中性能分析的复杂内容，重点关注逃逸分析、栈和指针，以及栈内存分配和堆内存分配之间微妙的相互关系等关键概念。通过探索这些基本方面，本章旨在让你掌握必要的知识和技能，以便对Go应用程序进行优化，实现最高效率和性能。

理解这些概念对于提高Go应用程序的性能，以及深入理解系统编程原理至关重要。在现实世界中，这些知识非常宝贵，高效的内存管理和性能优化会对软件项目的可扩展性、可靠性和整体成功产生重大影响。

本章将涵盖以下关键主题：

逃逸分析
基准测试
CPU性能分析
内存性能分析

在本章结束时，你将在分析和优化Go应用程序性能方面打下坚实的基础，为学习系统编程和应用开发中的更高级主题做好准备。

# 逃逸分析

逃逸分析是一种编译器优化技术，用于确定一个变量是否可以安全地在栈上分配，或者它是否必须“逃逸”到堆上。逃逸分析的主要目标是通过尽可能在栈上分配变量来改善内存使用和性能，因为栈分配比堆分配更快，并且对CPU缓存更友好。

# 栈和指针

在Go语言中，栈和指针是任何有能力的系统程序员的必备知识，但不知为何，它们也是让许多人困惑不已的源头。需要明确的是：如果你认为管理栈和指针易如反掌，那你可能没有真正理解它们。

想象一下在软件开发的世界里，指针就像那些需要不断了解你在哪里、在做什么的难伺候的朋友。只不过在这个世界里，要是不随时让它们知晓情况，后果可不只是伤感情，而是会让程序崩溃。这就是Go语言中栈和指针的复杂困境：就像一场永不停歇的派对，每个人都必须清楚自己的位置，否则一切都会乱套。

现在，让我们言归正传。在Go语言的语境中，栈是个既简单又复杂的存在。它是你所有局部变量的栖息地，这些变量在函数调用结束前短暂存在，之后便悄然退场。栈很高效、整洁，但要是你不按它的规则行事，它也绝不留情。

另一方面，指针是栈的外向“表亲”。它们并不存在于栈上，而是热衷于指向各种值，无论这些值位于何处。无论是在栈上、堆上，还是在内存管理的“神秘地带”，指针都是你直接操作数据的途径，它避开了值复制的繁琐过程，让你能直接访问内存。

对于任何Go程序员来说，理解栈和指针之间的相互作用至关重要。这意味着要清楚何时让变量在栈上过“无忧无虑”的生活，何时引入指针，去指向可能更持久的数据。这就像是一场内存管理、性能优化的舞蹈，同时还要避免可怕的段错误。

看下面这段简单的Go代码片段：

package main

import "fmt"

func main() {
    a := 42
    b := &a
    fmt.Println(a, *b) // Prints: 42 42
    *b = 21
    fmt.Println(a, *b) // Prints: 21 21
}

1
2
3
4
5
6
7
8
9
10
11

在这里，a是一个位于栈上的局部变量，过得很“开心”。b是指向a的指针，通过它我们可以直接操作a的值。这一小段代码展示了指针和栈的强大之处，以及它们在受控环境中的交互方式。

回想起我刚开始学习Go语言的日子，我记得有个项目饱受内存管理问题的困扰。那感觉就像迷失在森林里，而指针是我唯一的指南针。后来我意识到，指针和栈不仅仅是工具，更是Go语言内存管理的核心，这才取得了突破。这就好比我明白了，要在森林中找到方向，不仅要知道树在哪里，还得了解森林的生长规律。当我把指针比作小说中的书签时，我豁然开朗，书签标记着故事的重要部分，让我可以随意翻阅而不会迷失。

可以把栈想象成一摞盘子。晚饭后收拾餐具时，你会把盘子一个一个摞起来。最后放上去的盘子会第一个被清洗。Go语言中的栈在处理函数调用和局部变量时也是类似的原理。当一个函数被调用时，Go会把所需的所有东西（比如变量）都压入栈中。函数执行完毕后，Go会把这些东西清理掉，为下一个函数的内容腾出空间。这是一种高效的内存管理方式，而且完全自动，你都不用告诉Go去清理，它自己就会处理。

现在来谈谈指针。如果说栈是关于组织管理的，那么指针就是关于连接的。Go语言中的指针就像是知道朋友家的地址。你自己没有房子，但你知道去哪儿能找到它。在Go语言里，指针保存着变量的内存地址。这意味着你可以直接改变程序中其他地方变量的值，而无需传递变量本身。这就好比你发短信让朋友打开门廊的灯，而不用亲自走过去。指针之所以强大，是因为它能让你高效地操作数据。然而，能力越大，责任越大。滥用指针可能会导致难以追踪的错误。

在系统编程中，你常常需要更贴近硬件进行工作，此时效率和对内存的控制至关重要。了解栈的工作原理有助于你编写高效的函数，避免浪费内存。指针则让你能够直接与内存地址交互，这对于处理资源或操作底层系统结构等任务来说至关重要。这些概念在Go语言中非常基础，因为它们设计得既简单又强大。在很多情况下，Go会自动管理内存，但了解它如何管理以及为何这样管理，能让你在编写高性能应用程序时更具优势。无论你是在管理资源、优化性能，还是在调试程序，扎实掌握栈和指针会让你的工作轻松许多。所以，当我们更深入地研究Go语言的机制时，请记住：理解栈和指针不仅仅是记住定义，而是要深入理解Go语言系统编程的核心，这样才能写出更简洁、更快、更高效的代码。

# 指针

指针就像是你的瑞士军刀。它不仅仅是一个特性，更是一个能决定你代码效率和简洁性的基本概念。让我们揭开指针的神秘面纱，学习如何精准地使用它。

简单来说，指针是一个保存另一个变量地址的变量。它并不存储值本身，而是指向值在内存中的存储位置。想象一下你在一个大型音乐节现场。指针不是乐队表演的舞台，而是标注舞台位置的地图。在Go语言中，这个概念让你可以直接与数据的内存地址进行交互。

在Go语言中声明一个指针，需要在类型前面加上星号（*）。这是在告诉Go：“这个变量将保存一个内存地址，而不是直接存储值。” 示例如下：

var p *int

这行代码声明了一个指针p，它将指向一个整数。但此时，p还没有指向任何东西，就好比有一张地图，上面却没有标注任何地点。要让它指向一个实际的整数，必须使用取地址运算符（&）：

var x int = 10
p = &x

1
2

现在，p保存了x的地址，就像你在音乐节地图上标注出了舞台的位置。

解引用是访问指针所指向内存地址中的值的方式。你可以使用声明指针时的星号（*）来进行解引用，但使用场景不同：

fmt.Println(*p)

这行代码打印的不是p中存储的内存地址，而是p指向的x的值，这就是解引用的作用。就好比你不再看地图，而是站在了舞台前欣赏音乐。

使用指针，你可以在不复制数据的情况下操作数据，这在资源紧张或对速度要求极高的情况下，能节省时间和内存，是一个关键优势。指针还能让你与硬件交互、执行底层系统调用，或者以最高效的方式处理数据结构。

以下是一些使用指针的最佳实践：

保持简单：仅在必要时使用指针。Go语言的垃圾回收器在内存管理方面表现出色，但合理使用指针可以进一步提升性能。
空指针检查：在解引用之前，始终检查指针是否为nil，以避免运行时恐慌。
指针传递：向函数传递大型结构体时，使用指针以避免复制整个结构体，这样更快且更节省内存。

指针是掌握Go语言的关键，对于系统编程来说尤为重要，因为系统编程常常需要直接访问和操作内存。通过有效理解和应用指针，你能更深入地控制程序，为编写更高效、强大和复杂的系统级应用程序奠定基础。

# 栈

栈在内存管理中起着至关重要的作用，是内存管理的支柱。它是管理函数调用和局部变量的关键所在。让我们深入了解栈，以及它在系统编程中为何如此重要。

可以把栈想象成自助餐厅里一摞托盘。每个托盘代表一次函数调用，托盘上的餐具就像是函数的局部变量。当一个新函数被调用时，就会有一个新托盘被放到这摞托盘的顶部。函数返回时，这个托盘就会被拿走，不会留下任何“ mess”。这种后进先出的机制确保了最近调用的函数始终在栈顶，一旦函数执行完毕，就能立即清理。

Go语言利用栈来管理函数调用及其局部变量的生命周期。当一个函数被调用时，Go会自动在栈上为其局部变量分配空间。这些空间由Go高效管理，函数调用结束后，内存会被自动释放。这种自动管理方式对系统程序员来说非常方便，它简化了内存管理，提升了性能。

每次函数调用都会在栈上创建一个所谓的“栈帧”。这个栈帧包含了函数所需的所有信息，包括局部变量、参数和返回地址。栈帧对于函数的执行至关重要，它提供了一个自包含的内存块，由Go运行时高效管理。

虽然栈很高效，但它并非无限的。每个Go程序都有一个固定的栈大小，这意味着你需要注意函数调用和局部变量所使用的内存量。深度递归或大型局部变量可能会导致栈溢出，使程序崩溃。不过，Go的运行时会尝试通过使用动态调整大小的栈来缓解这个问题，栈会根据需要在一定范围内增长和收缩。

# 堆

回想一下我们自助餐厅的类比。栈和托盘很适合快速用餐的情况，所有东西都整齐地放在一个托盘上。但如果是自助餐或者一场精心准备的晚宴呢？你就需要一个更大、更灵活的空间来摆放所有东西。这就是堆的作用。

堆是内存中结构相对松散的区域。它就像一个巨大的储物间，Go可以根据需要在其中存储大小不一的数据。当你需要保存一个会随时间扩展或收缩的大型数组，或者创建一个由许多相互关联的部分组成的复杂对象时，堆就是你的首选之地。

这种灵活性的代价是速度会略有损失。系统需要跟踪堆上有什么、哪里有空闲空间，以及哪些内存不再使用。这种记录工作使得堆的操作比栈的流畅操作稍微慢一些。

# 栈和堆——内存管理的搭档

在Go语言中，栈和堆协同工作，配合默契。想象一下以下场景：

你编写了一个函数，创建了一个大型数据结构，比如链表。函数本身在栈上有一个整洁的位置（它的栈帧）。
链表及其节点和数据则在堆上获得空间，这样它可以根据需要增长和收缩。
在函数的栈帧内部，有一个指针指向堆上链表的起始位置。通过这种方式，函数可以找到并操作位于灵活堆空间中的数据结构。

堆虽然功能强大，但需要系统程序员格外留意。如果你不断从堆中分配和释放大小不一的内存块，随着时间的推移，堆可能会变得碎片化，更难找到连续的大空间。这就是常见的内存碎片化问题。

以下是一些关于内存分配的最佳实践：

尽量减少大型局部变量：对于大型数据结构，考虑使用堆来存储，避免占用过多栈空间。
谨慎使用递归：确保递归函数有明确的终止条件，防止栈溢出。
理解栈和堆的分配：对于生命周期短的变量，使用栈分配；对于生命周期长于函数调用的变量，使用堆分配。

我们可以通过逃逸分析来确定变量的存储位置。

那么，如何进行分析呢？

Go语言中的逃逸分析是一门高深的学问，即使是经验丰富的开发者，在代码审查时也会偷偷上网搜索相关知识，却还假装自己懂。这就好比声称自己喜欢自由爵士乐，听起来很厉害，直到有人让你解释一下才露馅。

想象一下在派对上，有人试图解释量子力学，但每一个解释都莫名其妙地扯到他们的酸面团发酵剂上。这就类似于在不实际动手写代码的情况下试图理解逃逸分析。它很复杂，还有点让人摸不着头脑，每个人都只是点头附和，其实并没有真正理解。

从本质上讲，逃逸分析是编译器决定Go程序中变量存储位置的方式。这就像一个严格的房东，决定你的变量是否可靠到能在栈上“租”一块空间，还是因为“行为不端”而被赶到堆上。这样做的目的是提高效率和速度。栈上的变量就像在你沙发上过夜的朋友，很容易管理，离开也很迅速。堆上的变量则更像是签了租约，需要更多的“手续”，过程也更慢。

编译器在编译阶段进行这种分析，仔细检查你的代码，预测变量的使用方式，以及它们是否会离开创建它们的函数的作用域。如果一个变量被返回给调用者，那么它就被认为“逃逸”了。这个决定对性能有重大影响。栈分配比堆分配更快，对CPU缓存更友好，而堆分配较慢，还需要垃圾回收。

为了理解这一点，让我们深入研究一个简单的代码示例：

func main() {
    a := 42
    b := &a
    fmt.Println(*b)
}

1
2
3
4
5

在这个代码片段中，a是一个整数，在简单情况下，它会愉快地待在栈上。然而，因为我们获取了它的地址并将其赋给b，编译器担心a可能会逃出main()函数的范围。因此，为了安全起见，编译器可能会决定将a分配到堆上，尽管在这个例子中它实际上并没有逃逸。

回想起我学习Go语言初期遇到的困难，我记得有个项目需要优化关键路径，这让我深入研究了逃逸分析。经过几个小时的性能分析和调整，我终于发现，一个被不经意间通过引用传递给多个函数的变量，正是导致堆分配问题的罪魁祸首。通过调整代码，让这个变量留在栈上，性能提升就像从骑着三轮车变成在高速公路上开跑车一样明显。

在Go语言中，一个协程（goroutine）的栈内存是严格私有的，没有协程可以拥有指向另一个协程栈的指针。这种隔离确保了运行时无需管理跨协程的复杂指针引用，简化了内存管理，避免了因栈大小调整可能导致的潜在延迟问题。

当一个值被传递到其函数栈帧之外时，为了确保它在函数调用结束后仍然存在，可能需要在堆上分配。编译器通过逃逸分析来做出这个决定。编译器会分析函数调用和变量引用，判断一个变量的生命周期是否超出当前栈帧，从而确定是否需要在堆上分配。

看下面这个示例，它展示了逃逸分析的实际应用：

package main

import "fmt"

type person struct {
    name string
    age  int
}

func main() {
    p := createPerson()
    fmt.Println(p)
}

//go:noinline
func createPerson() *person {
    p := person{name: "Alex Rios", age: 99}
    return &p
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

在这个例子中，createPerson函数创建了一个person结构体，并返回指向它的指针。由于return &p这行代码，person结构体“逃逸”到了堆上，因为它的引用被返回给了调用者，使其生命周期超出了createPerson函数的栈帧。

要查看Go编译器如何进行逃逸分析，可以使用-gcflags "-m -m"选项编译Go程序。

在ch9/escape-analysis目录下，执行以下命令：

Go build -gcflags "-m -m" .

你应该会看到类似以下的输出：

./main.go:16:6:  cannot  inline  createPerson:  marked  go:noinline
./main.go:10:6:  cannot  inline  main:  function  too  complex:  cost  141
exceeds  budget  80
./main.go:12:13:  inlining  call  to  fmt.Println
./main.go:17:2:  p  escapes  to  heap:
./main.go:17:2:      flow:  ~r0  =  &p:
./main.go:17:2:           from  &p  (address-of)  at  ./main.go:18:9
./main.go:17:2:           from  return  &p  (return)  at  ./main.go:18:2
./main.go:17:2:  moved  to  heap:  p
./main.go:12:13:  ...  argument  does  not  escape

1
2
3
4
5
6
7
8
9
10

这个命令会打印出关于编译器对变量分配决策的详细信息。理解这些报告有助于你通过减少不必要的堆分配，编写更高效的Go代码。

让我们更深入地探讨一下逃逸分析（escape analysis）带来的这个序列：

内联（Inlining）和go:noinline：

./main.go:16:6: cannot inline createPerson: marked go:noinline

- **内联**：内联是一种编译器优化技术，编译器会用函数的实际代码替换函数调用，这有可能提升性能。
- **`go:noinline`**：这个指令告诉编译器明确不要内联`createPerson`函数。对于复杂函数，或者内联会引入不良副作用时，有时有必要这么做。

复杂度成本和预算：

./main.go:10:6: cannot inline main: function too complex: cost 141 exceeds budget 80

- **复杂度成本**：Go编译器会为函数分配一个复杂度 “成本”。这个成本有助于判断内联一个函数是否可能带来好处。
- **预算**：编译器有一个默认的内联预算（在这个例子中是80）。如果超过这个预算，编译器就会认为该函数过于复杂，内联无法带来益处。

提示信息：

./main.go:12:13: inlining call to fmt.Println

这是一条提示信息。表明编译器成功内联了对fmt.Println函数的调用。保持fmt.Println的使用简单是个好习惯，这样能确保它不会妨碍内联。 4. 逃逸：

./main.go:17:2: p escapes to heap

- **逃逸分析**：Go会分析变量是否 “逃逸” 出当前函数的作用域。如果一个变量逃逸了，那么它必须在堆上分配内存（以获得更长的生命周期），而不是在栈上。

我们有一个变量p，在第18行返回了它的地址。由于这个地址可以在当前函数外部使用，所以p必须在堆上分配内存。

逃逸分析是Go编译器的一项强大功能，它通过确定变量最合适的分配位置，有助于高效管理内存。了解变量如何以及为何会逃逸到堆上，你就能编写更高效的Go程序，更好地利用系统资源。

在继续使用Go进行开发时，要牢记逃逸分析，尤其是在处理指针和函数返回值的时候。记住，我们的目标是让编译器优化内存使用，提升Go应用程序的性能。

虽然我们可以检查内存分配的位置，但如何确定性能是否有所提升呢？一个好的开端是对代码进行基准测试（benchmarking）。

# 对代码进行基准测试

在Go语言中进行基准测试，就像是开发者为追求性能提升而踏上的一场神圣仪式，但常常会迷失在微观优化的迷宫里。这就好比为了准备马拉松，却一门心思地计算系鞋带能有多快，完全忽略了更重要的训练计划。

想象一下，有一位经验丰富的软件开发人员，就像一位厨艺精湛的大厨，精心挑选每一种食材来烹制完美的菜肴。在这场烹饪之旅中，大厨知道选择喜马拉雅粉盐还是海盐，可不只是关乎口味——而是那些能让一道菜从不错变得惊艳的微妙差异。同样，在软件开发中，选择不同的算法或数据结构，也不只是纸上谈兵的速度或内存使用问题；而是要理解缓存未命中、分支预测和执行流水线之间复杂的相互作用。这是一种艺术形式，就像绘画时笔触和画布同样重要。

现在，让我们深入探讨一下Go语言中的基准测试。本质上，基准测试是一种系统地测量和比较软件性能的方法。它不只是运行一段代码，看看它执行得有多快；而是要创建一个可控的环境，在这个环境中你可以了解代码、算法或系统架构的变化所带来的影响。目标是提供可操作的见解，为优化工作提供指导，确保优化不是盲目进行的。

Go语言凭借其丰富的标准库和工具，提供了一个强大的基准测试框架。testing包堪称其中的瑰宝，它让开发者编写基准测试和编写单元测试一样简单。然后可以使用go test命令执行这些基准测试，该命令会提供详细的性能指标，可用于识别性能瓶颈或验证效率改进情况。

假设Fib是一个计算第n个斐波那契数的函数。要创建一个基准测试，你必须在_test.go文件中编写一个以Benchmark开头、并接受一个*testing.B参数的函数。使用go test命令来运行这些基准测试函数：

package benchmark

import (
    "testing"
)

func BenchmarkFib10(b *testing.B) {
    // 运行Fib函数b.N次
    for n := 0; n < b.N; n++ {
        Fib(10)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

这段代码展示了Go语言基准测试方法的核心：简洁、易读，并且专注于在可重复的条件下测量特定代码段的性能。b.N循环允许基准测试框架动态调整迭代次数，确保测量结果既准确又可靠。

# 编写你的第一个基准测试

在你的第一个基准测试中，你将创建一个名为Sum的函数，用于计算两个整数的和。基准测试函数BenchmarkSum用于测量执行Sum(1, 2)所需的时间。

实现代码如下：

package benchmark

import (
    "testing"
)

func BenchmarkSum(b *testing.B) { 
    for i := 0; i < b.N; i++ {
        Sum(1, 2)
    }
}

1
2
3
4
5
6
7
8
9
10
11

*testing.B参数为基准测试提供了控制和报告功能。*testing.B中最重要的字段是N，它表示基准测试函数应该执行被测代码的迭代次数。Go测试框架会自动确定最佳的N值，以获得可靠的测量结果。

要运行基准测试，使用带有-bench标志的go test命令，并指定一个正则表达式作为参数，用于匹配你想要运行的基准测试函数。例如，要运行所有基准测试，可以使用以下命令：

go test -bench=.

基准测试运行的输出会提供以下几方面的信息：

BenchmarkSum-8        1000000000        0.277  ns/op

具体解释如下：

BenchmarkSum-8：基准测试函数的名称，-8表示GOMAXPROCS的值，表明该基准测试是在并行度设置为8的情况下运行的。
1000000000：测试框架确定的迭代次数。
0.277 ns/op：每次操作的平均耗时（在这个例子中是纳秒/次操作）。

Go语言允许在一个基准测试函数中定义子基准测试，这使你能够系统地测试不同的场景或输入。下面展示如何使用子基准测试：

func BenchmarkSumSub(b *testing.B) {
    cases := []struct {
        name string
        a, b int
    }{
        {"small", 1, 2},
        {"large", 1000, 2000},
    }
    
    for _, c := range cases {
        b.Run(c.name, func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                Sum(c.a, c.b)
            }
        })
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个例子中：

结构体定义：定义了一个结构体切片，每个结构体代表一个测试用例，包含一个名称以及两个整数a和b。这些结构体用于为Sum函数提供不同的输入，以便在不同场景下对其性能进行基准测试。
遍历测试用例循环：代码使用for循环遍历每个测试用例。对于每个测试用例，它调用b.Run()来执行一个子基准测试。
使用b.Run()进行子基准测试：b.Run()函数接受两个参数：子基准测试的名称（从测试用例中派生而来）和一个包含实际基准测试代码的函数。这使得Go测试框架可以将每组输入视为一个单独的基准测试，并为每个测试提供单独的性能指标。
基准测试循环：在每个子基准测试函数内部，有一个循环运行b.N次，使用测试用例的输入调用Sum函数。这用于测量在特定输入条件下Sum函数的性能。

当我们再次使用基准测试标志运行测试时，结果应该如下所示：

BenchmarkSumSub/small-8                     1000000000                      0.3070  ns/op
BenchmarkSumSub/large-8                     1000000000                      0.2970  ns/op

1
2

很好！现在，我们可以探究程序各个部分使用了多少内存，以便更好地了解它们的行为。

# 内存分配

要测量内存分配情况，可以在运行基准测试时使用-benchmem标志。

这个标志会在输出中增加两列：allocs/op，表示每次操作的内存分配次数；B/op，表示每次操作分配的字节数。以下是使用-benchmem标志的示例输出：

BenchmarkSum-8        1000000000        0.277  ns/op        16  B/op        2  allocs/op

具体解释如下：

16 B/op：这表明每次操作（在这个例子中，每次调用Sum函数）分配16字节的内存。这个指标有助于确定代码的变化对其内存占用的影响。
2 allocs/op：这显示了每次操作发生的内存分配次数。在这个例子中，每次调用Sum函数会导致两次内存分配。减少分配次数通常可以提升性能，尤其是在紧密循环或对性能要求较高的代码段中。

目前进展顺利，但我们如何确定代码的更改是否有效呢？在这种情况下，我们应该依靠比较基准测试结果。

# 比较基准测试结果

为了比较基准测试结果，我们将使用一个名为benchstat的Go工具，它可以对基准测试结果进行统计分析。该工具在比较不同测试运行的基准测试输出时特别有用，能让你更轻松地了解代码不同版本之间的性能变化。

首先，你需要安装benchstat。假设你的系统已经安装了Go，可以使用go install命令来安装benchstat。从Go 1.16版本开始，建议在该命令中使用版本后缀：

go install golang.org/x/perf/cmd/benchstat@latest

这个命令会将benchstat二进制文件下载并安装到你的Go二进制目录（通常是$GOPATH/bin或$HOME/go/bin）。确保这个目录在系统的PATH中，这样你就可以在任何终端中运行benchstat。

首先，我们需要运行基准测试并将输出保存到文件中。你可以使用go test -bench命令运行基准测试，并将输出重定向到文件：

运行第一个基准测试：

go test -bench=. > old.txt

修改代码，然后运行以下命令：

go test -bench=. > new.txt

将基准测试结果保存到old.txt和new.txt后，你可以使用benchstat来比较这些结果，并分析性能差异：

benchstat old.txt new.txt

解读benchstat的输出

我们的新工具会以表格形式输出，包含几列信息。以下是输出示例：

name                  old  time/op       new  time/op        delta
BenchmarkSum-8        200ns  ± 1%           150ns  ± 2%     -25.00%     (p=0.008  n=5+5)

1
2

让我们仔细看看： - name：基准测试的名称。 - old time/op：第一组基准测试（来自old.txt）的每次操作平均时间。 - new time/op：第二组基准测试（来自new.txt）的每次操作平均时间。 - delta：从旧基准测试到新基准测试，每次操作时间的百分比变化。负的delta表示性能提升（代码运行更快），正的delta表示性能下降（代码运行更慢）。 - p：用于比较旧基准测试和新基准测试的统计检验（通常是t检验）的p值。较低的p值（通常小于0.05）表明观察到的性能差异在统计上是显著的。 - n：用于计算旧基准测试和新基准测试每次操作平均时间的样本数量。

统计学术语 `±`符号后面跟着一个百分比，表示每次操作平均时间的误差范围。它能让你了解基准测试结果的可变性。

benchstat二进制文件是分析Go代码性能的强大工具，它能清晰地对基准测试结果进行统计比较。记住，虽然benchstat可以突出显著的变化，但也要考虑基准测试的上下文以及任何性能差异在实际应用中的影响。

# 额外参数

在Go语言中运行基准测试时，你不仅可以灵活控制基准测试的运行时长和次数，还能选择运行特定的基准测试。当你致力于优化或调试代码的特定部分，并且只想运行与该部分代码相关的基准测试时，这一功能特别有用。-benchtime=、-count和-bench=标志可以有效地组合使用，以便有选择地运行基准测试，并精确控制它们的执行参数。

使用-bench=标志过滤基准测试

-bench=标志允许你指定一个正则表达式（regex），用于匹配你想要运行的基准测试的名称。只有名称与该正则表达式匹配的基准测试才会被执行。这对于有选择地运行基准测试，而无需运行整个测试套件来说非常有用。例如，假设你的包中有几个基准测试：BenchmarkSum、BenchmarkMultiply和BenchmarkDivide。

如果你只想运行BenchmarkMultiply，可以像这样使用-bench=标志：

go test -bench=BenchmarkMultiply

这个命令告诉Go测试运行器只执行名称与BenchmarkMultiply匹配的基准测试。匹配是区分大小写的，并且基于Go的正则表达式语法，这让你在指定运行哪些基准测试时拥有很大的灵活性。

组合使用所有标志

你可以将-bench=与-benchtime=和-count组合使用，以精细控制特定基准测试的执行。例如，如果你想让BenchmarkMultiply运行更长时间，并多次重复该基准测试以获得更可靠的测量结果，可以使用以下命令：

go test -bench=BenchmarkMultiply -benchtime=3s -count=5

这个命令会每次运行BenchmarkMultiply基准测试至少3秒钟，并将整个基准测试重复5次。当你试图衡量性能优化的影响，或者确保代码更改没有导致性能下降时，这种方法很有帮助。

过滤基准测试的技巧

过滤基准测试主要有三个技巧。第一个通常称为宽泛匹配。你可以使用更宽泛的正则表达式模式来匹配多个基准测试。例如，-bench=.会运行包中的所有基准测试，而-bench=Benchmark会运行任何以Benchmark开头的基准测试。

第二个技巧是按子基准测试进行过滤。如果你使用了子基准测试，也可以使用-bench=标志来指定运行特定的子基准测试。例如，如果你有名称为BenchmarkMultiply/small和BenchmarkMultiply/large的子基准测试，你可以使用-bench=BenchmarkMultiply/large来只运行 “large” 子基准测试。

最后一个技巧是确保避免意外匹配。注意正则表达式模式可能会匹配比你预期更多的基准测试。例如，-bench=Multiply会匹配BenchmarkMultiply，但如果存在BenchmarkComplexMultiply这样的基准测试，它也会被匹配到。使用更具体的模式来缩小你想要运行的基准测试范围。

使用-bench=过滤基准测试、使用-benchtime=控制基准测试时间，以及使用-count指定运行次数，为希望优化代码的Go开发者提供了一套强大的工具。通过仅运行你感兴趣的基准测试，并且在能提供有意义数据的时长和次数下运行，你可以更有效地聚焦优化工作，并更清晰地了解代码的性能特征。

# 常见陷阱

在基准测试过程中有很多常见陷阱。下面我们来探讨其中最常见的几种。

# 陷阱1——测试错误的内容

最基本的错误之一就是对代码中错误的部分进行基准测试。例如，在对一个对切片进行排序的函数进行基准测试时，如果切片仅排序一次，然后在基准测试的多次迭代中重复使用而不重新初始化，那么后续迭代将在已排序的数据上进行操作，这会使结果产生偏差。这个错误突出了为每次迭代正确设置基准测试状态的重要性，以确保你测量的是预期的操作。 解决方案：使用b.ResetTimer()并在基准测试循环中正确初始化状态，确保每次迭代都在相同条件下对操作进行基准测试。

# 陷阱2——编译器优化

和许多其他编译器一样，Go编译器会对代码进行优化，这可能会导致误导性的基准测试结果。例如，如果函数调用的结果未被使用，编译器可能会完全优化掉该调用。同样，常量传播可能会导致编译器用预先计算好的结果替换函数调用。 解决方案：为防止编译器优化掉你想要进行基准测试的代码，要确保使用操作的结果。相关技巧包括将结果赋值给包级变量，或使用runtime.KeepAlive来确保编译器在运行时按需要处理结果。

# 陷阱3——预热

现代CPU和系统具有不同级别的缓存和优化机制，这些机制需要时间来“预热”。在系统达到稳定状态之前过早开始测量，可能会导致结果不准确，无法反映典型的性能。 解决方案：在开始测量之前让系统预热。这可以包括在实际记录结果之前运行基准测试代码一段时间，或者在Go基准测试中使用b.ResetTimer()，以便在初始设置或预热阶段之后再开始计时。

# 陷阱4——环境

在与生产环境差异很大的环境中运行基准测试，可能会导致结果无法代表实际性能。硬件、操作系统、网络条件的差异，甚至基准测试运行时的负载，都会影响测试结果。 解决方案：尽可能在与生产环境相近的条件下运行基准测试。这包括使用相似的硬件、运行相同版本的Go运行时，以及模拟真实的负载和使用模式。

# 陷阱5——忽略垃圾回收和其他运行时开销

Go的运行时，包括垃圾回收，会对性能产生显著影响。没有考虑这些开销的基准测试可能无法准确反映用户将体验到的性能。 解决方案：要留意垃圾回收和其他运行时行为对基准测试的影响。使用运行时指标和分析工具来了解这些因素如何影响你的基准测试。可以考虑运行更长时间的基准测试，以捕捉垃圾回收周期的影响。

# 陷阱6——错误使用b.N

在Go基准测试中错误使用b.N参数会导致结果不准确和解读错误。至少有两种常见的错误使用b.N的场景，每种都有其问题。下面我们详细探讨一下。在某些情况下，开发人员可能会在基准测试的递归函数中错误使用b.N。这可能会导致意外行为和不准确的测量结果。例如：

func recursiveFibonacci(n int) int {
    if n <= 1 {
        return n
    }
    
    return recursiveFibonacci(b.N - 1) + recursiveFibonacci(b.N - 2) // Misusing b.N in the recursive call
}

func BenchmarkRecursiveFibonacci(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = recursiveFibonacci(10)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

在这种情况下，b.N被错误地用作recursiveFibonacci递归函数的参数。这种错误使用会导致意外行为和错误的基准测试结果。此外，当基准测试代码涉及复杂的设置或初始化，且这些操作不应在每次迭代时重复进行时，开发人员可能会错误使用b.N。例如：

type ComplexData struct {
    // ...
}

var data *ComplexData

func setupComplexData() *ComplexData {
    if data == nil {
        data =  //Initialize complex data
    }
    return data
}

func BenchmarkComplexOperation(b *testing.B) {
    // Misusing b.N for setup
    for i := 0; i < b.N; i++ {
        complexData := setupComplexData()
        _ = performComplexOperation(complexData)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个场景中，b.N被错误地用于在基准测试循环中重复执行设置代码。如果设置操作原本只应执行一次，那么这会使基准测试结果产生偏差。最后，开发人员可能会在涉及基于迭代次数的条件逻辑的基准测试中错误使用b.N。看下面这个例子：

func BenchmarkConditionalLogic(b *testing.B) {
    for i := 0; i < b.N; i++ {
        if i%2 == 0 {
            // Misusing b.N to conditionally execute code
            _ = performOperationA()
        } else {
            _ = performOperationB()
        }
    }
}

1
2
3
4
5
6
7
8
9
10

在这种情况下，b.N被错误地用于根据迭代次数有条件地执行不同的代码路径。这可能会导致基准测试结果不一致，使得性能测量结果难以解读。

总之，在Go语言（或者说任何语言）中进行基准测试，重点不在于单纯追求速度，而在于如何基于测试结果做出明智决策。这就像驾驶一艘船在波涛汹涌的海面上航行，没有指南针（基准测试）和熟练的领航员（开发人员），你只能随波逐流，难以到达目的地。真正的技能不在于你能开多快，而在于知道何时转向。

# CPU性能分析

CPU性能分析是分析Go程序不同部分消耗多少CPU时间的过程。这种分析有助于你识别以下方面：

瓶颈：那些消耗过多CPU时间，导致应用程序运行缓慢的代码区域。
低效之处：可以进行优化以减少CPU资源使用的函数或代码块。
热点：程序中执行最频繁的部分，这是优化的主要关注点。

为了进行性能分析，我们将创建一个文件变更监视器。该程序将监控指定目录中的文件变更。为简化范围，我们的程序将检测文件的创建、删除和修改操作。并且，在检测到变更时，它会发送警报（打印到控制台）。

完整代码可以在本书的GitHub仓库中找到。目前，我们来探索其核心功能和相应的代码部分，以便更清楚地了解它的运行方式：

首先，定义文件元数据结构：

type FileInfo struct {
    Name    string
    ModTime time.Time
    Size    int64
}

1
2
3
4
5

这个结构体定义了程序将跟踪的简化文件元数据，包括文件名、修改时间和文件大小。这对于将文件系统的当前状态与之前状态进行比较以检测变更至关重要。 2. 扫描目录：

func scanDirectory(dir string) (map[string]FileInfo, error) {
    results := make(map[string]FileInfo)
    err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }
        
        info, err := d.Info()
        if err != nil {
            return err
        }
        
        results[path] = FileInfo{
            Name:    info.Name(),
            ModTime: info.ModTime(),
            Size:    info.Size(),
        }
        
        return nil
    })
    
    return results, err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

scanDirectory函数使用filepath.WalkDir遍历目录及其子目录，收集每个文件的元数据并将其存储在一个映射中。这个映射作为扫描时目录状态的快照。 3. 比较目录状态：

func compareAndEmitEvents(oldState, newState map[string]FileInfo) {
    for path, newInfo := range newState {
        // ...
        go sendAlert(fmt.Sprintf("File created: %s", path))
        // ...
        go sendAlert(fmt.Sprintf("File modified: %s", path))
    }
    
    for path := range oldState {
        // ...
        go sendAlert(fmt.Sprintf("File deleted: %s", path))
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

compareAndEmitEvents函数遍历新旧状态映射以查找差异，这些差异表明文件的创建、删除或修改操作。对于每个检测到的变更，它会使用一个goroutine调用sendAlert，这使得这些警报可以异步处理。 4. 发送警报：

func sendAlert(event string) {
    fmt.Println("Alert:", event)
}

1
2
3

这个函数负责处理警报。在当前实现中，它只是将警报打印到控制台。为每个警报在单独的goroutine中运行此函数，可确保目录扫描和比较过程不会被警报机制阻塞。 5. 主监控循环：

func main() {
    // ...
    currentState, err := scanDirectory(dirToMonitor)
    // ...
    for {
        // ...
        newState, err := scanDirectory(dirToMonitor)
        compareAndEmitEvents(currentState, newState)
        currentState = newState
        time.Sleep(interval)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

在main()函数中，首先扫描目录以建立基线状态。然后程序进入一个循环，按指定间隔重新扫描目录，将新的扫描结果与之前的状态进行比较，并为下一次迭代更新状态。这个循环会一直持续，直到程序停止。 6. 使用goroutine发送警报：在compareAndEmitEvents函数中通过go sendAlert(...)异步执行sendAlert，可确保即使警报处理过程存在延迟，程序仍能保持响应，并且监控间隔保持一致。 7. 错误处理：代码的扫描部分和主循环部分都展示了错误处理，确保程序可以优雅地处理目录扫描过程中遇到的问题。不过，（特别是对于实际应用程序）详细的错误处理需要对各种错误情况进行更全面的检查和响应。

为了启用CPU性能分析，我们需要修改程序。首先，添加以下导入：

import (
    ...
    "runtime/pprof"
)

1
2
3
4

这从Go运行时导入了pprof包，该包提供了用于收集和写入性能分析数据的函数。

现在，我们可以使用这个包：

func main() {
    // ...
    f, err := os.Create("cpuprofile.out")
    if err != nil {
        // Handle error
    }
    
    defer f.Close()
    pprof.StartCPUProfile(f)
    defer pprof.StopCPUProfile()
    // ... (Rest of your code)
}

1
2
3
4
5
6
7
8
9
10
11
12

下面解释每一行的作用：

os.Create("cpuprofile.out")：这一行创建了一个名为cpuprofile.out的文件，CPU性能分析数据将写入该文件。这个文件在应用程序的当前工作目录中创建。
defer f.Close()：这一行确保函数返回时关闭文件。这对于保证所有数据都被刷新到磁盘并且文件被正确关闭很重要。这里，defer用于安排在函数完成后（包括正常完成或因错误提前返回）运行关闭操作。
pprof.StartCPUProfile(f)：这一行启动CPU性能分析过程。它接受一个io.Writer作为参数（在这种情况下是我们之前创建的文件），并开始记录CPU性能分析数据。从这一点开始，直到调用pprof.StopCPUProfile()，应用程序使用的所有CPU时间都将被记录下来。
defer pprof.StopCPUProfile()：这一行代码设定了CPU性能分析（CPU profiling）的停止时机，即当函数返回时停止。这能确保性能分析正常结束，并且在应用程序退出或执行后续操作之前，将所有收集到的数据写入指定文件。在这里使用defer至关重要，即使代码中出现错误或提前触发返回，也能保证性能分析停止。

现在，我们可以通过执行以下命令构建程序：

go build monitor.go

执行该程序，并确保它监控一个活动目录（你可以在其中模拟文件更改）：

./monitor

在程序运行时，在被监控的目录中进行更改操作：创建文件、删除文件，以及修改文件内容。这会为性能分析创造一个真实的工作负载。

启用CPU性能分析运行程序后，你可以使用Go的pprof工具分析cpuprofile.out文件，查看性能分析结果并找出代码中的热点函数。这一步对于性能调优和确保应用程序高效运行至关重要。

分析cpuprofile.out文件主要有两种方式：文本方式和火焰图（flame graph）方式。

要以文本方式分析性能分析数据，运行以下命令：

go tool pprof cpuprofile.out

你应该会看到类似以下的输出：

Total:  10  samples

550.0%  50.0%5    50.0%  compareAndEmitEvents330.0%  80.0%3    30.0%  scanDirectory110.0%  90.0%1    10.0%  filepath.WalkDir110.0%  100.0%1    10.0%  main

1
2
3

该结果按CPU消耗时间降序列出了各个函数。

由此，我们可以解读出应关注排在前面的几个条目。它们是进行优化的主要对象。此外，还可以查看调用栈（call stacks）。调用栈展示了在程序逻辑中是如何调用这些开销较大的函数的。

要使用火焰图分析性能分析数据，运行以下命令：

go tool pprof -web cpuprofile.out

这种方法提供了一种可视化的方式来确定热点函数。更宽的条表示使用CPU时间更多的函数。

你需要记住以下几点：

条的宽度：它代表函数所消耗CPU时间的比例。条越宽，消耗的时间越多。
层级结构：这展示了调用栈。调用其他函数的函数会堆叠在上面。
自上而下：从图的顶部开始分析，沿着条最宽的路径进行。

在开始修改程序并查看性能分析结果之前，让我们先学习如何对这个程序进行内存性能分析（memory profiling），以便在未来进行改进后，能清楚地了解内存和CPU之间的权衡。

# 内存性能分析

内存性能分析有助于你分析Go程序如何分配和使用内存。在系统编程中，这一点至关重要，因为在系统编程里，你经常要处理资源受限的情况以及对性能敏感的操作。它有助于解答以下一些关键问题：

内存泄漏：是否无意中持有不再需要的内存？
分配热点：哪些函数或代码块负责大部分内存分配？
内存使用模式：随着时间的推移，内存使用情况如何变化，尤其是在不同负载条件下？
对象大小：如何了解关键数据结构的内存占用情况？

让我们根据以下代码片段，学习如何为我们的监控程序设置内存性能分析：

f, err := os.Create("memprofile.out")
if err != nil {
    // Handle error
}

defer f.Close()
runtime.GC()
pprof.WriteHeapProfile(f)

1
2
3
4
5
6
7
8

让我们来理解一下这里发生了什么：

os.Create("memprofile.out")：这一行在当前工作目录中创建了一个名为memprofile.out的文件。这个文件用于存储内存性能分析数据。
defer f.Close()：这一行安排在周围的函数（main函数）返回时调用f的Close方法。这是为了确保文件被正确关闭，并且写入其中的所有数据都被刷新到磁盘，无论函数是正常退出还是因错误退出。
runtime.GC()：这一行是可选的，它在写入堆内存性能分析（heap profile）数据之前触发垃圾回收（garbage collection）。其目的是清理未使用的内存，以便在进行性能分析时，能更准确地显示程序实际正在使用的内存。这有助于识别程序真正需要的内存，而不是那些已准备好被回收但尚未回收的内存。
pprof.WriteHeapProfile(f)：这一行将内存性能分析数据写入之前创建的文件。这个性能分析数据包含程序内存分配的相关信息，通过分析这些信息，可以了解内存使用模式并识别潜在问题，例如内存泄漏。

我们可以再次构建并运行程序，但这一次，在模拟工作负载之后，我们会得到一个新文件：memprofile.out。

我们可以通过执行以下命令以文本方式分析这个文件：

go tool pprof memprofile.out

重点关注那些分配大量内存或长时间持有内存的函数。我们也可以通过执行以下命令使用基于网页的视图：

go tool pprof -web memprofile.out

请注意，我们现在看到的是一种火焰图变体。与CPU火焰图不同，这里条的宽度代表的不是时间，而是内存分配情况。

建议从顶部开始分析，找出内存使用量大的区域。在我们的程序中，有几个关键区域需要关注：

scanDirectory：构建map[string]FileInfo会分配多少内存？这个映射会随着目录大小的增加而增大。
compareAndEmitEvents：内存使用情况是否受文件更改频率的严重影响，或者比较逻辑本身的内存占用是否值得关注？
FileInfo：如果你处理的是非常大的文件或很长的文件路径，FileInfo结构体的大小可能会产生影响。

# 随时间进行内存性能分析

为了更好地了解潜在的内存泄漏或内存增长情况，可以执行以下操作：

修改代码，以便在监控循环中定期写入堆内存性能分析数据。
对比不同时间的性能分析数据，查看是否有对象意外地持续处于已分配状态，这可能意味着存在类似内存泄漏的情况。

# 准备探究权衡关系

为了探究性能分析技术的结果，让我们引入一个简单的缓存功能。

在引入任何缓存机制之前，我们应该先记录当前的情况。之后，我们可以设计缓存机制。让我们考虑以下几个方面：

逐出策略（Eviction policy）：当缓存达到大小限制时，如何删除旧数据？
带缓存的性能分析：分析新的内存性能分析数据。
改进：与scanDirectory相关的内存使用量是否减少了？
新的瓶颈：缓存本身是否成为了一个重要的内存消耗源？

# 简单缓存

下面是我们逐步实现简单缓存机制的过程：

全局缓存声明：

var cachedDirectoryState map[string]FileInfo // Global for simplicity

声明了一个名为cachedDirectoryState的全局变量，用于存储目录的缓存状态。这个映射使用文件路径作为索引，存储FileInfo结构体。将其声明为全局变量，可使缓存在多次调用scanDirectory函数时持续存在，从而能够复用之前收集的数据。 2. 在scanDirectory中进行缓存检查：

if cachedDirectoryState != nil {
    for path, fileInfo := range cachedDirectoryState {
        results[path] = fileInfo
    }
}

1
2
3
4
5

在执行文件系统遍历（filesystem walk）之前，该函数会检查是否存在现有缓存（cachedDirectoryState）。如果缓存不为nil，即之前的扫描已经填充了缓存，它会将缓存中的FileInfo条目复制到results映射中。这一步确保函数从上次扫描的数据开始处理，如果许多文件没有变化，就有可能减少所需的工作量。 3. 扫描后更新缓存：

err := filepath.WalkDir(dir, func(path string, d fs.DirEntry,
    err error) error {
    // ... (Existing logic from scanDirectory remains) ...
    // Update results and the cache
    results[path] = FileInfo{
        Name:    info.Name(),
        ModTime: info.ModTime(),
        Size:    info.Size(),
    }
    cachedDirectoryState = results
    return nil
})

1
2
3
4
5
6
7
8
9
10
11
12

在遍历目录并处理每个文件时，results映射会使用每个路径的最新FileInfo进行更新。与初始的缓存检查不同，这个更新操作发生在filepath.WalkDir调用内部，以确保捕获到最新信息。在处理完每个文件后，整个cachedDirectoryState会被当前的results替换。这意味着缓存始终反映目录的最新状态，即最后一次扫描确定的状态。

注意事项
如果在两次扫描之间文件发生了更改、添加或删除，并且程序在不重新验证缓存的情况下依赖缓存，这种缓存策略可能会引入数据过时的问题。为了缓解这个问题，你可以考虑根据某些触发条件或在预定义的时间间隔后，采用使缓存无效或更新缓存的策略。
一个适用于生产环境的缓存可能需要设置大小限制和逐出策略（例如最近最少使用（LRU）策略）。

现在，你需要再次进行内存和CPU分析，以确定程序的行为发生了哪些变化。确保为性能分析结果指定不同的名称，以免覆盖之前的结果！

从CPU的角度来看，你是否注意到消耗CPU时间最多的函数的排序发生了变化？特定函数的CPU时间百分比是否有显著的增加或减少？

希望你会看到scanDirectory函数中的CPU时间减少了。

从内存的角度来看，你是否注意到分配内存最多的函数发生了变化？特定函数的内存分配量是否有显著的增加或减少？

由于缓存本身，预计内存使用量会增加。分析这种权衡对于性能提升来说是否可以接受。对程序进行性能分析的核心思想是，理想情况下每次只更改代码或工作负载的一个方面，以便进行更清晰的比较。

至此，我们通过CPU和内存性能分析数据对应用程序进行了评估。

# 总结

在本章中，我们探讨了Go语言中性能分析的核心内容，帮助你理解Go的内存管理机制是如何工作的，以及如何对其进行优化以提高应用程序性能。我们深入研究了诸如逃逸分析（escape analysis）、栈（stack）和指针（pointers）的作用，以及栈内存分配和堆（heap）内存分配之间的区别等关键概念。

在我们结束对内存管理和性能优化复杂内容的学习之际，下一章将带领我们进入Go语言中广阔的网络编程世界。

← 第三部分：性能第10章网络编程→

第9章 性能分析

# 第9章 性能分析

# 逃逸分析

# 栈和指针

# 指针

# 栈

# 堆

# 栈和堆——内存管理的搭档

# 对代码进行基准测试

# 编写你的第一个基准测试

# 内存分配

# 比较基准测试结果

# 额外参数

# 常见陷阱

# 陷阱1——测试错误的内容

# 陷阱2——编译器优化

# 陷阱3——预热

# 陷阱4——环境

# 陷阱5——忽略垃圾回收和其他运行时开销

# 陷阱6——错误使用b.N

# CPU性能分析

# 内存性能分析

# 随时间进行内存性能分析

# 准备探究权衡关系

# 简单缓存

# 总结

第9章性能分析

# 第9章性能分析