GO内存逃逸是什么

一、我们说内存逃逸时在说什么

问，内存逃逸是干什么的
- 答，内存逃逸分析是编译器在编译优化时，用来决定变量应该分配在堆上还是栈上的工具
问，为什么要区分堆和栈？不都是内存吗？
- 答，这篇也许可以解答你的疑惑，简单来说，栈内存是用来存储函数出入参和局部变量的，这些变量随着函数的创建而创建、返回而消亡，栈内存的分配是线性的，这种分配方式有极高的效率。在其他语言，例如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()
}