一、我们说内存逃逸时在说什么
- 问，内存逃逸是干什么的
- 答，内存逃逸分析是编译器在编译优化时，用来决定变量应该分配在堆上还是栈上的工具
- 问，为什么要区分堆和栈？不都是内存吗？
- 答，这篇也许可以解答你的疑惑，简单来说，栈内存是用来存储函数出入参和局部变量的，这些变量随着函数的创建而创建、返回而消亡，栈内存的分配是线性的，这种分配方式有极高的效率。在其他语言，例如c，变量分配在哪里是由开发人员决定的，例如局部变量分配在栈上，调用malloc方法分配的内存在堆上。栈内存的分配与释放由编译器决定，堆内存的分配与释放则完全由开发人员决定。
- 问，那为什么go不能仿照c语言，让开发人员管理堆内存？
- 答，go是一款简单、高效的现代开发语言，怎么还会让开发人员自己管理内存，太落伍了
- 所以当go要自己做内存管理的时候，内存的分配和释放就交给了go运行时
- 变量到底要分配到栈还是堆上，变成了go语言需要处理的事情。一方面栈内存分配效率极高，另一方面堆内存gc又影响效率。所以尽可能让变量分配在栈上。
- ok，暂时信你！！那么内存逃逸分析就是为了尽量让变量找到正确的家？（栈上或者堆上）
- 聪明！都学会抢答了
- 开发人员自己决定变量分配到哪儿，要么将本不用分配到堆上的变量分配到了堆上（低效！），要么将需要分配到堆上的变量分配在了栈上（野指针！）
- go的内存逃逸分析同样也面临上面两个问题，它尽量将变量分配的位置安排得明明白白的
- 问，既然go已经在编译时做了内存逃逸分析，我们作为开发人员还关心这个干什么？
- 为了炫技！O(∩_∩)O哈哈~
- 了解了内存逃逸分析的原理后，我们就能够理解什么样的变量会被分配在栈上、什么样的变量会被分配在堆上。
- 当你的程序对性能非常敏感，你就可以使用内存逃逸工具的分析，查看哪些变量逃逸到了堆上，哪些没有逃逸。然后调整代码，再次提高你得程序性能
- 问，我的程序就是增删改查，不需要性能
- 门在那边 →
- 问，怎么进行内存逃逸分析？
- 答，go在编译时会进行内存逃逸分析，同样也给开发人员开放了内存逃逸信息
- 在编译时增加-m标志，如
go build -gcflags="-m"，就会输出内存逃逸信息 - 下面我们会对几种常见的内存逃逸情况进行测试和分析
二、几种常见的内存逃逸情况
原生类型的逃逸分析
1. 变量分配在栈上的情况
当原生类型被取地址且地址被赋值给了一个指针变量，当这个指针变量只是在函数内部使用，则这个原生类型会被分配在栈上（即使是通过new方法分配的）
2. 变量逃逸到堆上的情况
如果这个指针变量被以某种形式作为了函数返回值（例如，指针变量是struct中的变量，struct是函数返回值），则这个原生类型被分配在堆上（原因很简单，如果分配在栈上，函数返回后栈中的数据失效，这个指针指向的地址就是无效的）
上代码
main.go
package main
type (
Foo struct {
A int
B string
}
FooHasPointer struct {
A *int
B string
}
)
// 返回了指向了a的指针，a逃逸到堆上
func escapeValue() *int {
var a int // moved to heap: a
a = 1
return &a
}
// 即使newa是指针类型，但是它只在本函数内起作用（没有被作为返回值，相当于一个局部变量），分配到栈上
func noescapeNew() {
newa := new(int) // noescapeNew new(int) does not escape
*newa = 1
}
// 指向i的指针被存储到foo结构体中返回了，i逃逸到堆上
func escapePointer() FooHasPointer {
var foo FooHasPointer
i := 10 //moved to heap: i
foo.A = &i
foo.B = "a"
return foo
}
// 没有指针，都分配到栈上
func noescapeValue() Foo {
var foo Foo
i := 10
foo.A = i
foo.B = "a"
return foo
}
func main() {
}
执行编译，并且附加-m内存逃逸分析标志和-l（L的小写）禁止内联标志
go build -gcflags "-m -l" main.go
结果如下：
.\main.go:17:6: moved to heap: a
.\main.go:24:13: noescapeNew new(int) does not escape
.\main.go:31:2: moved to heap: i
slice类型的逃逸分析
与原生类型的逃逸分析相似，当返回指向slice的指针时，slice逃逸；当返回slice时，只有slice中的数据逃逸
slice的逃逸分为slice本身（即SliceHeader）的逃逸分析，和slice中的元素（即SliceHeader中Data指向的地址）的逃逸分析
1. SliceHeader分配在栈上、Data分配在堆上
当SliceHeader分配在栈上，Data既可以分配在栈上也可以分配在堆上
- 当Data的空间不足、需要动态扩容时，Data会被分配在堆上
- 当初始化slice时，Data所占空间达到64K时，SliceHeader和Data都会被分配在堆上（注意这里的64K边界是在自己的windows和linux机上测试到的，没有找go源码的出处，有可能不准确，理解为Data比较大时会直接分配在堆上比较好。另外除了slice，其他的数据类型如果初始化大小超过某个阈值时，应该也会直接分配在堆上）
2. 当SliceHeader分配在堆上，SliceHeader和Data都分配在堆上
上代码
package main
import (
"reflect"
"strconv"
"unsafe"
)
// sl为局部变量，SliceHeader没有逃逸，Data由于动态扩容分配在了堆上
func noEscapeSliceWithDataInHeap() {
var sl []byte
println("addr of local(no escape, data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// sl为局部变量，SliceHeader没有逃逸，Data不需要动态扩容，分配在栈上
func noEscapeSliceWithDataInStack() {
sl := make([]byte, 0, 10) // noEscapeSliceWithDataInStack make([]byte, 0, 10) does not escape
println("addr of local(no escape, data in stack) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// Data过大，SliceHeader和Data直接分配在堆上
func escapeLargeSlice() {
sl := make([]byte, 0, 1024*64) //make([]byte, 0, 1024 * 64) escapes to heap
println("addr of local(escape, data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// Data没有达到64k，没有逃逸
func noescapeSmallSlice() {
sl := make([]byte, 0, 1024*63+1023) // noescapeSmallSlice make([]byte, 0, 1024 * 63 + 1023) does not escape
println("addr of local(no escape, data in stack) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
}
// 返回了sl的指针，SliceHeader和Data都逃逸了
func escapeSliceWithDataInHeap() *[]byte {
sl := make([]byte, 0, 10) //moved to heap: sl // make([]byte, 0, 5) escapes to heap
println("addr of local(slice and data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
return &sl
}
// sl作为返回值，SliceHeader没有逃逸，Data逃逸
func sliceInStackWithDataInHeap() []byte {
sl := make([]byte, 0, 10) //make([]byte, 0, 5) escapes to heap
println("addr of local(slice in stack and data in heap) slice = ", &sl)
printSliceHeader(&sl)
for i := 0; i < 10; i++ {
println("append " + strconv.Itoa(i))
sl = append(sl, byte(i))
printSliceHeader(&sl)
}
return sl
}
func printSliceHeader(p *[]byte) {
ph := (*reflect.SliceHeader)(unsafe.Pointer(p))
println("slice data = ", unsafe.Pointer(ph.Data))
}
func main() {
noEscapeSliceWithDataInHeap()
noEscapeSliceWithDataInStack()
escapeLargeSlice()
noescapeSmallSlice()
escapeSliceWithDataInHeap()
sliceInStackWithDataInHeap()
}
执行编译，并且附加-m内存逃逸分析标志和-l禁止内联标志
go build -gcflags "-m -l" main.go
结果如下：
.\main.go:83:23: printSliceHeader p does not escape
.\main.go:15:21: noEscapeSliceWithDataInHeap "append " + strconv.Itoa(i) does not escape
.\main.go:23:12: noEscapeSliceWithDataInStack make([]byte, 0, 10) does not escape
.\main.go:27:21: noEscapeSliceWithDataInStack "append " + strconv.Itoa(i) does not escape
.\main.go:35:12: make([]byte, 0, 1024 * 64) escapes to heap
.\main.go:39:21: escapeLargeSlice "append " + strconv.Itoa(i) does not escape
.\main.go:47:12: noescapeSmallSlice make([]byte, 0, 1024 * 63 + 1023) does not escape
.\main.go:51:21: noescapeSmallSlice "append " + strconv.Itoa(i) does not escape
.\main.go:59:2: moved to heap: sl
.\main.go:59:12: make([]byte, 0, 10) escapes to heap
.\main.go:63:21: escapeSliceWithDataInHeap "append " + strconv.Itoa(i) does not escape
.\main.go:72:12: make([]byte, 0, 10) escapes to heap
.\main.go:76:21: sliceInStackWithDataInHeap "append " + strconv.Itoa(i) does not escape
map类型的逃逸分析
1. 不作为函数返回值时，分配在栈上
2. 作为函数返回值且返回的不是指针时，map的元素分配在堆上，map本身分配在栈上
3. 作为函数返回值且返回的是指针时，map的元素分配在堆上，map本身也分配在堆上
上代码
package main
func noEscapeMap() {
sm := make(map[int]int) //noEscapeMap make(map[int]int) does not escape
sm[1] = 1
}
func escapeMap() map[int]int {
sm := make(map[int]int) // make(map[int]int) escapes to heap
sm[1] = 1
return sm
}
func escapeMapPointer() *map[int]int {
sm := make(map[int]int) // moved to heap: sm // make(map[int]int) escapes to heap
sm[1] = 1
return &sm
}
func main() {
noEscapeMap()
escapeMap()
}
执行编译，并且附加-m内存逃逸分析标志和-l禁止内联标志
go build -gcflags "-m -l" main.go
结果如下：
.\main.go:4:12: noEscapeMap make(map[int]int) does not escape
.\main.go:9:12: make(map[int]int) escapes to heap
.\main.go:15:2: moved to heap: sm
.\main.go:15:12: make(map[int]int) escapes to heap
三、后话
最后祭出go逃逸分析要遵循的两个不变性：
- 指向栈对象的指针不能存在于堆中
- 指向栈对象的指针不能在栈对象回收后存活
经过上面的分析和测试，这两条不变性也就很好理解了，懂得都懂!
友情提示
内存逃逸go在编译的时候就已经为我们优化好了，学习它是为了将性能提高至极致以及熟悉一些稍底层的知识。普通的代码不需要在逃不逃逸上杠。
网友评论