1 简介

Go 的逃逸分析就像一个被许多开发人员忽视的超能力。这不仅仅是关于内存管理;这是关于从代码中榨取每一点性能。我很高兴能学到这种“神秘”的东西并且分享给各位。奖励好奇的开发人员！

逃逸分析显示变量在内存中的存储位置。堆上的变量使用速度较慢，需要垃圾回收，而堆栈上的变量速度更快，并且会自动清理。

通常内存中的变量栈分配速度更快，并且对于生存期较短的变量是首选，
而堆分配对于具有较长生命周期或较大范围的变量是必需的。

逃逸分析只是 Go 性能工具包中的一个工具。结合内联、边界检查消除和高度优化的垃圾回收器等其他功能，它有助于提高 Go 的生产力和高性能。

让我们从基础开始。在 Go 中，变量可以在堆栈或堆上分配。堆栈分配更快、更高效，但它有局限性。堆更灵活，但会带来性能成本。这就是逃逸分析的用武之地。

本文来逐行解析你的输出日志，让你完全读懂每一条！

2 栈

变量被分配到两个主要内存位置：堆栈 Stack 和堆 Heap。让我们详细了解一下这些：

堆栈：
堆栈是以后进先出 （LIFO） 方式运行的内存区域。程序中的每个函数调用都会获得自己的堆栈帧，其中包含函数的局部变量、参数和返回值。
堆栈速度很快，因为它遵循简单的 push and pop 机制。它也是自动管理的，这意味着一旦函数退出，堆栈上分配的变量就会被释放。
该堆栈非常适合存储仅限于函数范围的短期变量。
当调用函数时，其堆栈帧被推送到堆栈上。当函数退出时，其堆栈帧将弹出，从而释放内存。

func Stack() int {
		 a:= 10 // 'a'  变量被分配到栈
		 b:= 20 // 'b' 变量被分配到栈
		 
		 value := a + b // value 值在堆栈上分配
		 return value // 当函数退出时，所有堆栈变量都会被弹出
	}

		func main(){
		 result := Stack() 
		 fmt.Println("result is : " , result)
		}

此处， a，b ，vaule 和 result 都在堆栈 Stack 上分配，因为它们的范围仅限于函数。
当函数退出时，这些变量会在其Stack 堆栈帧弹出时自动从内存中删除。

3 堆

堆是用于动态分配的内存区域。与栈不同，堆没有与函数调用绑定的严格生命周期。

在堆上分配的变量将一直存在，直到垃圾回收器确定它们不再使用。

堆比栈慢，因为内存管理涉及垃圾回收器，并且可能需要更复杂的指针取消引用。

堆用于存储其生命周期超出创建它们的函数或 goroutine 范围的变量。

func Heap() *int{
	n := 10
    return &n
	}

func main(){
	  ptr := Heap() // “ptr”指向的值在堆上分配
	  fmt.Println(*ptr) // 通过指针访问 Heap Allocated 变量
	}

在这里， 变量 n 被分配到堆Heap上，因为它的地址转义了函数并在main中被访问。

Go 使用逃逸分析来确定变量的分配位置。如果编译器可以确认变量的生存期仅限于函数的执行，则会在堆栈上分配该变量。
但是，如果变量的生命周期超出函数的范围（例如，通过指针或引用），它会在堆上分配变量。

逃逸分析的实际应用，要了解逃逸分析的工作原理，请考虑以下示例。

4 示例

在继续 Go语言编程之旅时，鼓励尝试一下逃逸分析。使用该标志 -gcflags=-m，对代码进行基准测试或运行，并查看微小的更改如何影响分配模式。

但干净、可读的代码应始终是您的首要任务。在需要时进行优化，但不要让它成为一种痴迷。
Go 的优势在于它的简单性和清晰度，再聪明的优化也无法弥补难以理解和维护的代码。

逃逸分析只是 Go 试图让我们作为开发人员的生活更轻松的众多方式之一。这证明了该语言在不牺牲性能的情况下保持简单性。

通过理解和利用这样的功能，我们可以编写不仅快速而且使用起来很愉快的 Go 代码。

该实例 go build -gcflags=-m 输出是 Go 编译器在进行逃逸分析（escape analysis）时的详细日志，用于告诉你哪些变量被分配在了堆上（moved to heap）以及为什么它们逃逸了（逃出了栈作用域，必须堆分配）。

简单来说，Go 会分析变量的使用方式：

如果一个变量只在当前函数内部使用，它就可以分配在栈上（更快，函数结束时释放）。

如果一个变量被传递到外部函数，或其地址被长期保留，Go 编译器认为它“逃逸”了，需要分配到堆上（更慢，由 GC 回收）。

程序如下：

	func main() {
	 x := 5
	 y := square(x)
	 fmt.Println("the square is : ", *y)
	}

	func square(x int) *int {
	 y := x * x
	 return &y
	}

该程序将输入的数做平方运算后返回，square函数中的变量y在堆上分配，因为它作为指针返回，从而允许在函数square范围之外访问它。
Go 编译器检测到 square转义函数并将y其移动到堆中。

逃逸分析使用指令：

		go build -gcflags=-m main.go

或

		go run -gcflags=-m main.go

📋 go run -gcflags=-m main.go 输出解析

		./main.go:11:6: can inline square
		./main.go:7:13: inlining call to square        
		./main.go:8:13: inlining call to fmt.Println   
		./main.go:8:13: ... argument does not escape   
		./main.go:8:14: "the square is : " escapes to heap
		./main.go:8:34: *y escapes to heap
		./main.go:12:2: moved to heap: y
		the square is :  25

我们逐行看：

🟥 0. 前三行为 内联函数调用

内联函数square, 内联对 square 的调用，对fmt.Println的调用。

✅ 安全、无逃逸。

    ./main.go:8:13: ... argument does not escape 

第8行13列为止没有逃逸。

这表示：

第 8 行第 13 列，调用的是 fmt.Println(…) 这种“变长参数”（…interface{}）。

Go 编译器发现这些参数是值传递、不会泄露引用，不需要堆分配。

🟥 1. "the square is : " escapes to heap

字符 "the square is : " 被分配到堆。

这些变量也都因为相似原因——它们的地址或值被传给 fmt.Println，进而逃逸到了堆。
类似之前的原因，y 的地址被传给 fmt.Println，导致它逃逸。

同样 "b’s memory address - " 也逃逸，因为作为 interface 被使用。

🟥 2. ./main.go:8:34: * y escapes to heap

含义：

文件：main.go

行号：第 8 行

列号：第 34 列（一般是变量名位置）

内容：变量 * y 被分配到了堆上。

原因？ 继续往下看就知道了——因为你打印了它的地址并传递到了 fmt.Println 中，这种“取地址 + 外部调用”会导致变量逃逸。

🟥 3. ./main.go:12:2: moved to heap: y

文件：main.go

行号：第 12 行

列号：第 2 列（一般是变量名位置）

内容：变量 y 被分配到了堆上。

后面几行为运行输出：

the square is :  25

5 简单示例验证

你可以写一个极简例子，然后运行：

	func test() *int {
	    a := 43
	    return &a // 这会让 a 逃逸到 堆 heap
	}

运行：

	go build -gcflags=-m main.go

你将看到：

	main.go:3:6: moved to heap: a

变量a移动到堆，因为它被返回了。

6 小结

判断变量是否逃逸的几种常见原因

		逃逸原因									说明
		传递变量地址到函数			fmt.Println(&a)，变量地址可能在函数内被保留
		将变量赋值给 interface		fmt.Println(a) 实际上包裹为 interface{}
		闭包捕获变量					被闭包引用的变量会逃逸
		返回变量地址					return &a，a 必须堆分配
		map/slice中存放指针			如果 slice 或 map 存在时间比局部变量久，变量需逃逸

通过使用逃逸分析，您可以：

查找性能问题：确定代码中减慢速度的部分。
简化代码：调整它以避免不必要的堆使用。
使程序更快：提高程序的运行效率。
最小化堆分配：除非必要，否则避免返回指向局部变量的指针。
适当时按值传递：对于较小的结构或值，请按值而不是按引用传递，以减少堆分配。
使用分析工具：这些工具可以帮助您了解程序的内存使用情况并确定需要改进的领域。pprof
逃逸分析检查：定期使用 -gcflags "-m" 以确保变量按预期分配。

更深入地研究 Go 的逃逸分析，你将开始对编译器的思考方式产生直觉。您将开始编写代码，这些代码不仅可以正常工作，还可以与 Go 运行时的内存管理很好地配合。

但请记住过早的优化是万恶之源。不要让逃逸分析问题驱动您的初始设计。
先写出清晰、惯用的 Go，然后根据需要进行分析和优化。Go 编译器和运行时非常智能，通常最易读的代码也是最高效的。

逃逸分析知识最强大的用途不是微观优化，而是整体系统设计。
了解数据如何流经您的程序以及分配发生的位置可以帮助您做出更好的架构决策。

例如在高性能服务器中，您可以设计数据结构和算法，以最大程度地减少请求处理路径中的分配。

在数据处理管道中，您可以仔细管理数据在各个阶段之间的传递方式，以避免不必要的复制或分配。