Go 学习笔记（75）— 栈内存、堆内存、逃逸分析

转自：
https://kaiwu.lagou.com/course/courseInfo.htm?courseId=536#/detail/pc?id=5247

为了让程序员更好地专注于业务代码的实现，Go 语言增加了垃圾回收机制，自动地回收不再使用的内存。Go 语言有两部分内存空间：栈内存和堆内存。

1. 栈内存

栈只允许往线性表的一端放入数据，之后在这一端取出数据,按照后进先出(LIFO, Last In First Out )的顺序，如图所示。

往栈中放入元素的过程叫做入栈。入栈会增加栈的元素数量，最后放入的元素总是位于栈的顶部，最先放入的元素总是位于栈的底部。

从栈中取出元素时，只能从栈顶部取出。取出元素后,栈的数量会变少。最先放入的元素总是最后被取出，最后放入的元素总是最先被取出。不允许从栈底获取数据，也不允许对栈成员(除栈顶外的成员)进行任何查看和修改操作 。

栈内存由编译器自动分配和释放，开发者无法控制。栈内存一般存储函数中的局部变量、参数等，函数创建的时候，这些内存会被自动创建；函数返回的时候，这些内存会被自动释放。

栈可用于内存分配，栈的分配和回收速度非常快。下面代码展示枝在内存分配上的作用，代码如下:

func calc(a, b int) int {
	var c int
	c = a * b

	var x int
	x = c * 10

	return x
}

上面的代码在没有任何优化情况下，会进行 c 和 x 变量的分配过程 。 Go 语言默认情况下会将 c 和 x 分配在栈上，这两个变量在 calc() 函数退出时就不再使用，函数结束时，保存 c 和 x 的栈内存再出栈释放内存，整个分配内存的过程通过栈的分配和回收都会非常迅速。

2. 堆内存

堆在内存分配中类似于往一个房间里摆放各种家具，家具的尺寸有大有小。

分配内存时，需要找一块足够装下家具的空间再摆放家具。经过反复摆放和腾空家具后，房间里的空间会变得乱七八糟，此时再往空间里摆放家具会存在虽然有足够的空间，但各空间分布在不同的区域，无法有一段连续的空间来摆放家具的问题。

此时内存分配器就需要对这些空间进行调整优化，如图所示。

堆分配内存和栈分配内存相比，堆适合不可预知大小的内存分配。但是为此付出的代价是分配速度较慢，而且会形成内存碎片 。

堆内存的生命周期比栈内存要长，如果函数返回的值还会在其他地方使用，那么这个值就会被编译器自动分配到堆上。堆内存相比栈内存来说，不能自动被编译器释放，只能通过垃圾回收器才能释放，所以栈内存效率会很高。

2. 逃逸分析

既然栈内存的效率更高，肯定是优先使用栈内存。那么 Go 语言是如何判断一个变量应该分配到堆上还是栈上的呢？这就需要逃逸分析了。下面我通过一个示例来讲解逃逸分析，代码如下：

package main

func main() {
    newString()
}

func newString() *string{
   s:=new(string)
   *s = "wohu"
   return s
}

现在我通过逃逸分析来看下是否发生了逃逸，命令如下：

wohu@ubuntu:~/gocode/src$ go build -gcflags="-m -l" demo.go
# command-line-arguments
./demo.go:12:10: new(string) escapes to heap
wohu@ubuntu:~/gocode/src$ 

• -m 表示打印出逃逸分析信息；
• -l 表示禁止内联，可以更好地观察逃逸；

从以上输出结果可以看到，发生了逃逸，也就是说指针作为函数返回值的时候，一定会发生逃逸。

逃逸到堆内存的变量不能马上被回收，只能通过垃圾回收标记清除，增加了垃圾回收的压力，所以要尽可能地避免逃逸，让变量分配在栈内存上，这样函数返回时就可以回收资源，提升效率。

下面我对 newString 函数进行了避免逃逸的优化，优化后的函数代码如下：

func newString() string{
   s:=new(string)
   *s = "wohu"
   return *s
}

再次通过命令查看以上代码的逃逸分析，命令如下：

wohu@ubuntu:~/gocode/src$ go build -gcflags="-m -l" demo.go
# command-line-arguments
./demo.go:8:10: newString new(string) does not escape
wohu@ubuntu:~/gocode/src$ 

通过分析结果可以看到，虽然还是声明了指针变量 s，但是函数返回的并不是指针，所以没有发生逃逸。

逃逸分析是判断变量是分配在堆上还是栈上的一种方法，在实际的项目中要尽可能避免逃逸，这样就不会被 GC 拖慢速度，从而提升效率。

小技巧：从逃逸分析来看，指针虽然可以减少内存的拷贝，但它同样会引起逃逸，所以要根据实际情况选择是否使用指针。

取地址发生逃逸

package main

import "fmt"

type Data struct {
}

func demo() *Data {
	var d Data
	return &d
}

func main() {
	fmt.Println(demo())
}

执行结果：

wohu@wohu-dev:~/gocode/src$ go run -gcflags "-m -l" temp.go 
# command-line-arguments
./temp.go:9:6: moved to heap: d
./temp.go:14:13: main ... argument does not escape
./temp.go:14:18: demo() escapes to heap
&{}
wohu@wohu-dev:~/gocode/src$ 

moved to heap: d。这句话表示， Go 编译器已经确认如果将 d 变量分配在栈上是无法保证程序最终结果的。如果坚持这样做，demo() 的返回值将是 Data 结构的一个不可预知的内存地址。这种情况一般是 C/C++ 语言中容易犯错的地方 ：引用了一个函数局部变量的地址。

Go 语言最终选择将 d 的 Data 结构分配在堆上。然后由垃圾回收器去回收 d 的内存 。

优化技巧

• 尽可能避免逃逸，因为栈内存效率更高，还不用 GC。比如小对象的传参，array 要比 slice效果好。

• 如果避免不了逃逸，还是在堆上分配了内存，那么对于频繁的内存申请操作，我们要学会重用内存，比如使用 sync.Pool。

• 选用合适的算法，达到高性能的目的，比如空间换时间。

小提示：性能优化的时候，要结合基准测试，来验证自己的优化是否有提升。

以上是基于 Go 语言的内存管理机制总结出的 3 个方向的技巧，基于这 3 个大方向基本上可以优化出你想要的效果。除此之外，还有一些小技巧，比如要尽可能避免使用锁、并发加锁的范围要尽可能小、使用 StringBuilder 做 string 和 []byte 之间的转换、defer 嵌套不要太多等等。

最后推荐一个 Go 语言自带的性能剖析的工具 pprof，通过它你可以查看 CPU 分析、内存分析、阻塞分析、互斥锁分析。