介绍

Go 语言较之 C 语言一个很大的优势就是自带 GC 功能，可 GC 并不是没有代价的。写 C 语言的时候，在一个函数内声明的变量，在函数退出后会自动释放掉，因为这些变量分配在栈上。如果你想要变量的数据能在函数退出后还能访问，就需要调用 malloc 方法在堆上申请内存，如果程序不再需要这块内存了，再调用 free 方法释放掉。Go 语言不需要你主动调用 malloc 来分配堆空间，编译器会自动分析，找出需要 malloc 的变量，使用堆内存。编译器的这个分析过程就叫做逃逸分析。
所以你在一个函数中通过 dict := make(map[string]int) 创建一个 map 变量，其背后的数据是放在栈空间上还是堆空间上，是不一定的。这要看编译器分析的结果。
可逃逸分析并不是百分百准确的，它有缺陷。有的时候你会发现有些变量其实在栈空间上分配完全没问题的，但编译后程序还是把这些数据放在了堆上。如果你了解 Go 语言编译器逃逸分析的机制，在写代码的时候就可以有意识的绕开这些缺陷，使你的程序更高效。

关于堆栈

Go 语言虽然在内存管理方面降低了编程门槛，即使你不了解堆栈也能正常开发，但如果你要在性能上较真的话，还是要掌握这些基础知识。
这里不对堆内存和栈内存的区别做太多阐述。简单来说就是，栈分配廉价，堆分配昂贵。栈空间会随着一个函数的结束自动释放，堆空间需要 GC 模块不断的跟踪扫描回收。如果对这两个概念有些迷糊，建议阅读下面 ２ 个文章：

这里举一个小例子，来对比下堆栈的差别：

  1. func stack() int { 
  2.     // 变量 i 会在栈上分配
  3.      i := 10
  4.      return i
  5. }
  6. func heap() *int {
  7.     // 变量 j 会在堆上分配
  8.     j := 10
  9.     return &j
  10. }

stack 函数中的变量 i 在函数退出会自动释放；而 heap 函数返回的是对变量i的引用，也就是说 heap()退出后，表示变量 i 还要能被访问，它会自动被分配到堆空间上。
他们编译出来的代码如下：

  1. // go build --gcflags '-l' test.go
  2. // go tool objdump ./test
  3. TEXT main.stack(SB) /tmp/test.go
  4.   test.go:7     0x487240        48c74424080a000000  MOVQ $0xa, 0x8(SP)  
  5.   test.go:7     0x487249        c3          RET         
  6. TEXT main.heap(SB) /tmp/test.go
  7.   test.go:9     0x487250        64488b0c25f8ffffff  MOVQ FS:0xfffffff8, CX          
  8.   test.go:9     0x487259        483b6110        CMPQ 0x10(CX), SP           
  9.   test.go:9     0x48725d        7639            JBE 0x487298                
  10.   test.go:9     0x48725f        4883ec18        SUBQ $0x18, SP              
  11.   test.go:9     0x487263        48896c2410      MOVQ BP, 0x10(SP)           
  12.   test.go:9     0x487268        488d6c2410      LEAQ 0x10(SP), BP           
  13.   test.go:10        0x48726d        488d05ac090100      LEAQ 0x109ac(IP), AX            
  14.   test.go:10        0x487274        48890424        MOVQ AX, 0(SP)              
  15.   test.go:10        0x487278        e8f33df8ff      CALL runtime.newobject(SB)      
  16.   test.go:10        0x48727d        488b442408      MOVQ 0x8(SP), AX            
  17.   test.go:10        0x487282        48c7000a000000      MOVQ $0xa, 0(AX)            
  18.   test.go:11        0x487289        4889442420      MOVQ AX, 0x20(SP)           
  19.   test.go:11        0x48728e        488b6c2410      MOVQ 0x10(SP), BP           
  20.   test.go:11        0x487293        4883c418        ADDQ $0x18, SP              
  21.   test.go:11        0x487297        c3          RET                 
  22.   test.go:9     0x487298        e8a380fcff      CALL runtime.morestack_noctxt(SB)   
  23.   test.go:9     0x48729d        ebb1            JMP main.heap(SB)           
  24. // ...
  25. TEXT runtime.newobject(SB) /usr/share/go/src/runtime/malloc.go
  26.   malloc.go:1067    0x40b070        64488b0c25f8ffffff  MOVQ FS:0xfffffff8, CX          
  27.   malloc.go:1067    0x40b079        483b6110        CMPQ 0x10(CX), SP           
  28.   malloc.go:1067    0x40b07d        763d            JBE 0x40b0bc                
  29.   malloc.go:1067    0x40b07f        4883ec28        SUBQ $0x28, SP              
  30.   malloc.go:1067    0x40b083        48896c2420      MOVQ BP, 0x20(SP)           
  31.   malloc.go:1067    0x40b088        488d6c2420      LEAQ 0x20(SP), BP           
  32.   malloc.go:1068    0x40b08d        488b442430      MOVQ 0x30(SP), AX           
  33.   malloc.go:1068    0x40b092        488b08          MOVQ 0(AX), CX              
  34.   malloc.go:1068    0x40b095        48890c24        MOVQ CX, 0(SP)              
  35.   malloc.go:1068    0x40b099        4889442408      MOVQ AX, 0x8(SP)            
  36.   malloc.go:1068    0x40b09e        c644241001      MOVB $0x1, 0x10(SP)         
  37.   malloc.go:1068    0x40b0a3        e888f4ffff      CALL runtime.mallocgc(SB)       
  38.   malloc.go:1068    0x40b0a8        488b442418      MOVQ 0x18(SP), AX           
  39.   malloc.go:1068    0x40b0ad        4889442438      MOVQ AX, 0x38(SP)           
  40.   malloc.go:1068    0x40b0b2        488b6c2420      MOVQ 0x20(SP), BP           
  41.   malloc.go:1068    0x40b0b7        4883c428        ADDQ $0x28, SP              
  42.   malloc.go:1068    0x40b0bb        c3          RET                 
  43.   malloc.go:1067    0x40b0bc        e87f420400      CALL runtime.morestack_noctxt(SB)   
  44.   malloc.go:1067    0x40b0c1        ebad            JMP runtime.newobject(SB)

逻辑的复杂度不言而喻，上面的汇编中可看到， heap() 函数调用了 runtime.newobject() 方法，它会调用 mallocgc 方法从 mcache 上申请内存，申请的内部逻辑前面文章已经讲述过。堆内存分配不仅分配上逻辑比栈空间分配复杂，它最致命的是会带来很大的管理成本，Go 语言要消耗很多的计算资源对其进行标记回收（也就是 GC 成本）。

不要以为使用了堆内存就一定会导致性能低下，使用栈内存会带来性能优势。因为实际项目中，系统的性能瓶颈一般都不会出现在内存分配上。千万不要盲目优化，找到系统瓶颈，用数据驱动优化。

逃逸分析

Go 编辑器会自动帮我们找出需要进行动态分配的变量，它是在编译时追踪一个变量的生命周期，如果能确认一个数据只在函数空间内访问，不会被外部使用，则使用栈空间，否则就要使用堆空间。
我们在 go build 编译代码时，可使用 -gcflags '-m' 参数来查看逃逸分析日志。

  1. go build -gcflags '-m -m' test.go

以上面的两个函数为例，编译的日志输出是：

  1. /tmp/test.go:11:9: &i escapes to heap
  2. /tmp/test.go:11:9:  from ~r0 (return) at /tmp/test.go:11:2
  3. /tmp/test.go:10:2: moved to heap: i
  4. /tmp/test.go:16:18: heap() escapes to heap
  5. /tmp/test.go:16:18:     from ... argument (arg to ...) at /tmp/test.go:16:13
  6. /tmp/test.go:16:18:     from *(... argument) (indirection) at /tmp/test.go:16:13
  7. /tmp/test.go:16:18:     from ... argument (passed to call[argument content escapes]) at /tmp/test.go:16:13
  8. /tmp/test.go:16:13: main ... argument does not escape

日志中的 &i escapes to heap 表示该变量数据逃逸到了堆上。

逃逸分析的缺陷

需要使用堆空间则逃逸，这没什么可争议的。但编译器有时会将不需要使用堆空间的变量，也逃逸掉。这里是容易出现性能问题的大坑。网上有很多相关文章，列举了一些导致逃逸情况，其实总结起来就一句话：
多级间接赋值容易导致逃逸。

这里的多级间接指的是，对某个引用类对象中的引用类成员进行赋值。Go 语言中的引用类数据类型有 func, interface, slice, map, chan, *Type(指针)。
记住公式 Data.Field = Value，如果 Data, Field 都是引用类的数据类型，则会导致 Value 逃逸。这里的等号 = 不单单只赋值，也表示参数传递。
根据公式，我们假设一个变量 data 是以下几种类型，相应的可得出结论：

  • []interface{}: data[0] = 100 会导致 100 逃逸
  • map[string]interface{}: data["key"] = "value" 会导致 "value" 逃逸
  • map[interface{}]interface{}: data["key"] = "value" 会导致 key 和 value 都逃逸
  • map[string][]string: data["key"] = []string{"hello"} 会导致切片逃逸
  • map[string]*int: 赋值时 *int 会 逃逸
  • []*int: data[0] = &i 会使 i 逃逸
  • func(*int): data(&i) 会使 i 逃逸
  • func([]string): data([]{"hello"}) 会使 []string{"hello"} 逃逸
  • chan []string: data <- []string{"hello"} 会使 []string{"hello"} 逃逸
  • 以此类推，不一一列举了

下面给出一些实际的例子：

函数变量

如果变量值是一个函数，函数的参数又是引用类型，则传递给它的参数都会逃逸。

  1. func test(i int)        {}
  2. func testEscape(i *int) {}
  3. func main() {
  4.     i, j, m, n := 0, 0, 0, 0
  5.     t, te := test, testEscape // 函数变量
  6.     // 直接调用
  7.     test(m)        // 不逃逸
  8.     testEscape(&n) // 不逃逸
  9.     // 间接调用
  10.     t(i)   // 不逃逸
  11.     te(&j) // 逃逸
  12. }
  1. ./test.go:4:17: testEscape i does not escape
  2. ./test.go:11:5: &j escapes to heap
  3. ./test.go:11:5:     from te(&j) (parameter to indirect call) at ./test.go:11:4
  4. ./test.go:7:5: moved to heap: j
  5. ./test.go:14:13: main &n does not escape

上例中 te 的类型是 func(*int)，属于引用类型，参数 *int 也是引用类型，则调用 te(&j) 形成了为 te 的参数(成员) *int 赋值的现象，即 te.i = &j 会导致逃逸。代码中其他几种调用都没有形成多级间接赋值情况。
同理，如果函数的参数类型是 slice, map 或 interface{} 都会导致参数逃逸。

  1. func testSlice(slice []int)       {}
  2. func testMap(m map[int]int)       {}
  3. func testInterface(i interface{}) {}
  4. func main() {
  5.     x, y, z := make([]int, 1), make(map[int]int), 100
  6.     ts, tm, ti := testSlice, testMap, testInterface
  7.     ts(x) // ts.slice = x 导致 x 逃逸
  8.     tm(y) // tm.m = y 导致 y 逃逸
  9.     ti(z) // ti.i = z 导致 z 逃逸
  10. }
  1. ./test.go:3:16: testSlice slice does not escape
  2. ./test.go:4:14: testMap m does not escape
  3. ./test.go:5:20: testInterface i does not escape
  4. ./test.go:8:17: make([]int, 1) escapes to heap
  5. ./test.go:8:17:     from x (assign-pair) at ./test.go:8:10
  6. ./test.go:8:17:     from ts(x) (parameter to indirect call) at ./test.go:10:4
  7. ./test.go:8:33: make(map[int]int) escapes to heap
  8. ./test.go:8:33:     from y (assign-pair) at ./test.go:8:10
  9. ./test.go:8:33:     from tm(y) (parameter to indirect call) at ./test.go:11:4
  10. ./test.go:12:4: z escapes to heap
  11. ./test.go:12:4:     from ti(z) (parameter to indirect call) at ./test.go:12:4

匿名函数的调用也是一样的，它本质上也是一个函数变量。有兴趣的可以自己测试一下。

间接赋值

  1. type Data struct {
  2.     data  map[int]int
  3.     slice []int
  4.     ch    chan int
  5.     inf   interface{}
  6.     p     *int
  7. }
  8. func main() {
  9.     d1 := Data{}
  10.     d1.data = make(map[int]int) // GOOD: does not escape
  11.     d1.slice = make([]int, 4)   // GOOD: does not escape
  12.     d1.ch = make(chan int, 4)   // GOOD: does not escape
  13.     d1.inf = 3                  // GOOD: does not escape
  14.     d1.p = new(int)             //  GOOD: does not escape
  15.     d2 := new(Data)             // d2 是指针变量， 下面为该指针变量中的指针成员赋值
  16.     d2.data = make(map[int]int) // BAD: escape to heap
  17.     d2.slice = make([]int, 4)   // BAD:  escape to heap
  18.     d2.ch = make(chan int, 4)   // BAD:  escape to heap
  19.     d2.inf = 3                  // BAD:  escape to heap
  20.     d2.p = new(int)             // BAD:  escape to heap
  21. }
  1. ./test.go:20:16: make(map[int]int) escapes to heap
  2. ./test.go:20:16:    from d2.data (star-dot-equals) at ./test.go:20:10
  3. ./test.go:21:17: make([]int, 4) escapes to heap
  4. ./test.go:21:17:    from d2.slice (star-dot-equals) at ./test.go:21:11
  5. ./test.go:22:14: make(chan int, 4) escapes to heap
  6. ./test.go:22:14:    from d2.ch (star-dot-equals) at ./test.go:22:8
  7. ./test.go:23:9: 3 escapes to heap
  8. ./test.go:23:9:     from d2.inf (star-dot-equals) at ./test.go:23:9
  9. ./test.go:24:12: new(int) escapes to heap
  10. ./test.go:24:12:    from d2.p (star-dot-equals) at ./test.go:24:7
  11. ./test.go:13:16: main make(map[int]int) does not escape
  12. ./test.go:14:17: main make([]int, 4) does not escape
  13. ./test.go:15:14: main make(chan int, 4) does not escape
  14. ./test.go:16:9: main 3 does not escape
  15. ./test.go:17:12: main new(int) does not escape
  16. ./test.go:19:11: main new(Data) does not escape

Interface

只要使用了 Interface 类型(不是 interafce{})，那么赋值给它的变量一定会逃逸。因为 interfaceVariable.Method() 先是间接的定位到它的实际值，再调用实际值的同名方法，执行时实际值作为参数传递给方法。相当于interfaceVariable.Method.this = realValue

  1. type Iface interface {
  2.     Dummy()
  3. }
  4. type Integer int
  5. func (i Integer) Dummy() {}
  6. func main() {
  7.     var (
  8.         iface Iface
  9.         i     Integer
  10.     )
  11.     iface = i
  12.     iface.Dummy() //  make i escape to heap
  13.     // 形成 iface.Dummy.i = i
  14. }

引用类型的 channel

向 channel 中发送数据，本质上就是为 channel 内部的成员赋值，就像给一个 slice 中的某一项赋值一样。所以 chan *Type, chan map[Type]Type, chan []Type, chan interface{} 类型都会导致发送到 channel 中的数据逃逸。
这本来也是情理之中的，发送给 channel 的数据是要与其他函数分享的，为了保证发送过去的指针依然可用，只能使用堆分配。

  1. func test() {
  2.     var (
  3.         chInteger   = make(chan *int)
  4.         chMap       = make(chan map[int]int)
  5.         chSlice     = make(chan []int)
  6.         chInterface = make(chan interface{})
  7.         a, b, c, d  = 0, map[int]int{}, []int{}, 32
  8.     )
  9.     chInteger <- &a  // 逃逸
  10.     chMap <- b       // 逃逸
  11.     chSlice <- c     // 逃逸
  12.     chInterface <- d // 逃逸
  13. }
  1. ./escape.go:11:15: &a escapes to heap
  2. ./escape.go:11:15:  from chInteger <- &a (send) at ./escape.go:11:12
  3. ./escape.go:9:3: moved to heap: a
  4. ./escape.go:9:31: map[int]int literal escapes to heap
  5. ./escape.go:9:31:   from b (assigned) at ./escape.go:9:3
  6. ./escape.go:9:31:   from chMap <- b (send) at ./escape.go:12:8
  7. ./escape.go:9:40: []int literal escapes to heap
  8. ./escape.go:9:40:   from c (assigned) at ./escape.go:9:3
  9. ./escape.go:9:40:   from chSlice <- c (send) at ./escape.go:13:10
  10. ./escape.go:14:14: d escapes to heap
  11. ./escape.go:14:14:  from chInterface <- (interface {})(d) (send) at ./escape.go:14:14
  12. ./escape.go:5:21: test make(chan *int) does not escape
  13. ./escape.go:6:21: test make(chan map[int]int) does not escape
  14. ./escape.go:7:21: test make(chan []int) does not escape
  15. ./escape.go:8:21: test make(chan interface {}) does not escape

可变参数

可变参数如 func(arg ...string) 实际与 func(arg []string) 是一样的，会增加一层访问路径。这也是 fmt.Sprintf 总是会使参数逃逸的原因。
例子非常多，这里不能一一列举，我们只需要记住分析方法就好，即，2 级或更多级的访问赋值会容易导致数据逃逸。这里加上容易二字是因为随着语言的发展，相信这些问题会被慢慢解决，但现阶段，这个可以作为我们分析逃逸现象的依据。
下面代码中包含 2 种很常规的写法，但他们却有着很大的性能差距，建议自己想下为什么。

  1. type User struct {
  2.     roles []string
  3. }
  4. func (u *User) SetRoles(roles []string) {
  5.     u.roles = roles
  6. }
  7. func SetRoles(u User, roles []string) User {
  8.     u.roles = roles
  9.     return u
  10. }

Benchmark 和 pprof 给出的结果:

  1. BenchmarkUserSetRoles-8     50000000            22.3 ns/op        16 B/op          1 allocs/op
  2. BenchmarkSetRoles-8         2000000000           0.51 ns/op        0 B/op          0 allocs/op
  3.   768.01MB   768.01MB (flat, cum)   100% of Total
  4.          .          .      3:import "testing"
  5.          .          .      4:
  6.          .          .      5:func BenchmarkUserSetRoles(b *testing.B) {
  7.          .          .      6:   u := new(User)
  8.          .          .      7:   for i := 0; i < b.N; i++ {
  9.   768.01MB   768.01MB      8:       u.SetRoles([]string{"admin"}) <- 看这里
  10.          .          .      9:   }
  11.          .          .     10:}
  12.          .          .     11:
  13.          .          .     12:func BenchmarkSetRoles(b *testing.B) {
  14.          .          .     13:   for i := 0; i < b.N; i++ {
  15. ROUTINE ======================== testing.(*B).launch in /usr/share/go/src/testing/benchmark.go
  16. ......

结论

熟悉堆栈概念可以让我们更容易看透 Go 程序的性能问题，并进行优化。
多级间接赋值会导致 Go 编译器出现不必要的逃逸，在一些情况下可能我们只需要修改一下数据结构就会使性能有大幅提升。这也是很多人不推荐在 Go 中使用指针的原因，因为它会增加一级访问路径，而 map, slice, interface{}等类型是不可避免要用到的，为了减少不必要的逃逸，只能拿指针开刀了。
大多数情况下，性能优化都会为程序带来一定的复杂度。建议实际项目中还是怎么方便怎么写，功能完成后通过性能分析找到瓶颈所在，再对局部进行优化。

作者：达菲格
链接：https://www.jianshu.com/p/518466b4ee96
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。