Go 逃逸分析

原文地址：Go 逃逸分析

什么是逃逸分析

堆和栈

要理解什么是逃逸分析会涉及堆和栈的一些基本知识，若是忘记的同窗咱们能够简单的回顾一下：

• 堆（Heap）：通常来说是人为手动进行管理，手动申请、分配、释放。堆适合不可预知大小的内存分配，这也意味着为此付出的代价是分配速度较慢，并且会造成内存碎片。
• 栈（Stack）：由编译器进行管理，自动申请、分配、释放。通常不会太大，所以栈的分配和回收速度很是快；咱们常见的函数参数（不一样平台容许存放的数量不一样），局部变量等都会存放在栈上。

栈分配内存只须要两个CPU指令：“PUSH”和“RELEASE”，分配和释放；而堆分配内存首先须要去找到一块大小合适的内存块，以后要经过垃圾回收才能释放。

通俗比喻的说，栈就如咱们去饭馆吃饭，只须要点菜（发出申请）--》吃吃吃（使用内存）--》吃饱就跑剩下的交给饭馆（操做系统自动回收），而堆就如在家里作饭，大到家，小到买什么菜，每个环节都须要本身来实现，可是自由度会大不少。
在编译程序优化理论中，逃逸分析是一种肯定指针动态范围的方法，简单来讲就是分析在程序的哪些地方能够访问到该指针。

逃逸分析

再往简单的说，Go是经过在编译器里作逃逸分析（escape analysis）来决定一个对象放栈上仍是放堆上，不逃逸的对象放栈上，可能逃逸的放堆上；即我发现变量在退出函数后没有用了，那么就把丢到栈上，毕竟栈上的内存分配和回收比堆上快不少；反之，函数内的普通变量通过逃逸分析后，发如今函数退出后变量还有在其余地方上引用，那就将变量分配在堆上。作到按需分配（哪里的人民须要我，我就往哪去~~，一个党员的呐喊）。

为什么须要逃逸分析

ok，了解完堆和栈各自的优缺点后，咱们就能够更好的知道逃逸分析存在的目的了：

1. 减小gc压力，栈上的变量，随着函数退出后系统直接回收，不须要gc标记后再清除。
2. 减小内存碎片的产生。
3. 减轻分配堆内存的开销，提升程序的运行速度。

如何肯定是否逃逸

在Go中经过逃逸分析日志来肯定变量是否逃逸，开启逃逸分析日志：

go run -gcflags '-m -l' main.go

• -m 会打印出逃逸分析的优化策略，实际上最多总共能够用 4 个 -m，可是信息量较大，通常用 1 个就能够了。
• -l 会禁用函数内联，在这里禁用掉内联能更好的观察逃逸状况，减小干扰。

逃逸案例

案例一：取地址发生逃逸

package main

type UserData struct {
    Name  string
}

func main() {
    var info UserData
    info.Name = "WilburXu"
    _ = GetUserInfo(info)
}

func GetUserInfo(userInfo UserData) *UserData {
    return &userInfo
}

执行 go run -gcflags '-m -l' main.go 后返回如下结果：

# command-line-arguments
.\main.go:14:9: &userInfo escapes to heap
.\main.go:13:18: moved to heap: userInfo

GetUserInfo函数里面的变量 userInfo 逃到堆上了（分配到堆内存空间上了）。

GetUserInfo 函数的返回值为 *UserData 指针类型，而后 将值变量userInfo 的地址返回，此时编译器会判断该值可能会在函数外使用，就将其分配到了堆上，因此变量userInfo就逃逸了。

优化方案

func main() {
    var info UserData
    info.Name = "WilburXu"
    _ = GetUserInfo(&info)
}

func GetUserInfo(userInfo *UserData) *UserData {
    return userInfo
}

# command-line-arguments
.\main.go:13:18: leaking param: userInfo to result ~r1 level=0
.\main.go:10:18: main &info does not escape

对一个变量取地址，可能会被分配到堆上。可是编译器进行逃逸分析后，若是发现到在函数返回后，此变量不会被引用，那么仍是会被分配到栈上。套个取址符，就想骗补助？

编译器傲娇的说：Too young，Too Cool...！

案例二 ：未肯定类型

package main

type User struct {
    name interface{}
}

func main() {
    name := "WilburXu"
    MyPrintln(name)
}

func MyPrintln(one interface{}) (n int, err error) {
    var userInfo = new(User)
    userInfo.name = one // 泛型赋值 逃逸咯
    return
}

执行 go run -gcflags '-m -l' main.go 后返回如下结果：

# command-line-arguments
./main.go:12:16: leaking param: one
./main.go:13:20: MyPrintln new(User) does not escape
./main.go:9:11: name escapes to heap

这里可能有同窗会好奇，MyPrintln函数内并无被引用的便利，为何变了name会被分配到了堆上呢？

上一个案例咱们知道了，普通的手法想去"骗取补助"，聪明灵利的编译器是不会“上当受骗的噢”；可是对于interface类型，很遗憾，编译器在编译的时候很难知道在函数的调用或者结构体的赋值过程会是怎么类型，所以只能分配到堆上。

优化方案

将结构体User的成员name的类型、函数MyPringLn参数one的类型改成 string，将得出：

# command-line-arguments
./main.go:12:16: leaking param: one
./main.go:13:20: MyPrintln new(User) does not escape

拓展分析

对于案例二的分析，咱们还能够经过反编译命令go tool compile -S main.go查看，会发现若是为interface类型，main主函数在编译后会额外多出如下指令：

# main.go:9 -> MyPrintln(name)
    0x001d 00029 (main.go:9)    PCDATA    $2, $1
    0x001d 00029 (main.go:9)    PCDATA    $0, $1
    0x001d 00029 (main.go:9)    LEAQ    go.string."WilburXu"(SB), AX
    0x0024 00036 (main.go:9)    PCDATA    $2, $0
    0x0024 00036 (main.go:9)    MOVQ    AX, ""..autotmp_5+32(SP)
    0x0029 00041 (main.go:9)    MOVQ    $8, ""..autotmp_5+40(SP)
    0x0032 00050 (main.go:9)    PCDATA    $2, $1
    0x0032 00050 (main.go:9)    LEAQ    type.string(SB), AX
    0x0039 00057 (main.go:9)    PCDATA    $2, $0
    0x0039 00057 (main.go:9)    MOVQ    AX, (SP)
    0x003d 00061 (main.go:9)    PCDATA    $2, $1
    0x003d 00061 (main.go:9)    LEAQ    ""..autotmp_5+32(SP), AX
    0x0042 00066 (main.go:9)    PCDATA    $2, $0
    0x0042 00066 (main.go:9)    MOVQ    AX, 8(SP)
    0x0047 00071 (main.go:9)    CALL    runtime.convT2Estring(SB)

对于Go汇编语法不熟悉的能够参考 Golang汇编快速指南

案例三：间接赋值（Assignment to indirection escapes）

对某个引用类对象中的引用类成员进行赋值。Go 语言中的引用类数据类型有 func, interface, slice, map, chan, *Type(指针)。

package main

type User struct {
    name interface{}
    age *int
}

func main() {
    var (
        userOne User
        userTwo = new(User)
    )
    userOne.name = "WilburXuOne"    // 不逃逸
    userTwo.name = "WilburXuTwo"    // 逃逸

    userOne.age = new(int)    // 不逃逸
    userTwo.age = new(int)    // 逃逸
}

执行 go run -gcflags '-m -l' main.go 后返回如下结果：

# command-line-arguments
.\main.go:14:17: "WilburXuTwo" escapes to heap
.\main.go:17:19: new(int) escapes to heap
.\main.go:11:16: main new(User) does not escape
.\main.go:13:17: main "WilburXuOne" does not escape
.\main.go:16:19: main new(int) does not escape

为何这里值类型不会逃逸而引用类型会逃逸呢？这是由于在 userTwo = new(User) 对象的建立时，编译器先是分析userTwo 对象可能分配在堆上，同时成员变量 name 和 age 也为引用类型，为了保证不出现栈回收后，致使对象userTwo的成员值也被回收，因此name和age须要逃逸。

可是，若是name和age为值类型，那么编译器虽然初步分析userTwo会分配在堆上，但因为main主函数结束后，变量都会被回收，也就是说对象没有被其余引用，那么就都会分配在栈上，因此name和age没有发生逃逸。

优化建议

尽可能不要将引用对象赋值给引用对象。

总结

不要盲目使用变量的指针做为函数参数，虽然它会减小复制操做。但其实当参数为变量自身的时候，复制是在栈上完成的操做，开销远比变量逃逸后动态地在堆上分配内存少的多。

Go的编译器就如一个聪明的孩子通常，大多时候在逃逸分析问题上的处理都使人眼前一亮，但有时闹性子的时候处理也是很是粗糙的分析或彻底放弃，毕竟这是孩子天性不是吗？ 因此也须要咱们在编写代码的时候多多观察，多多留意了。

参考文章

http://www.agardner.me/golang...

https://segmentfault.com/a/11...

https://docs.google.com/docum...

http://npat-efault.github.io/...