一文弄清楚Golang内存逃逸

　　1. 为什么要了解内存逃逸
　　c/c++的programmer对于堆内存、栈内存一定非常熟悉，以为内存管理完全由使用者自己管理。Go语言的内存管理完全由Go的runtime接管，那么是不程序员就完全不用care变量是如何分配的呢？减少了gc压力。如果变量都分配到堆上，堆不像栈可以自动清理。它会引起Go频繁地进行垃圾回收，而垃圾回收会占用比较大的系统开销，甚至会导致STW(stop the world)。提高分配效率。堆和栈相比，堆适合不可预知大小的内存分配。但是为此付出的代价是分配速度较慢，而且会形成内存碎片。栈内存分配则会非常快。但当我们的服务发现性能瓶颈，要如何去定位瓶颈，让我们的程序运行的更快，就非常有必要了解Go的内存分配。2. 什么是内存逃逸
　　Go语言中局部的非指针变量通常是不受GC管理的，这种Go变量的内存分配称为＂栈分配＂，处于goroutine自己的栈中。由于Go编译器无法确定其生命周期，因此无法以这种方式分配内存的Go变量会逃逸到堆上，被称为 内存逃逸 。3. 哪些情况下会发生内存逃逸
　　先来说一下通过go编译器查看内存逃逸方式go build -gcflags=-m xxx.go局部变量被返回造成逃逸package main  type User struct { 	Namestring }  func foo(s string) *User {    u := new(User)    u.Name= s    return u // 方法内局部变量返回，逃逸 }  func main() {    user := foo(＂hui＂)    user.Name= ＂dev＂ }  //# command-line-arguments //./escape.go:7:6: can inline foo //./escape.go:13:6: can inline main //./escape.go:14:13: inlining call to foo //./escape.go:7:10: leaking param: s //./escape.go:8:10: new(User) escapes to heap //./escape.go:14:13: new(User) does not escape  interface{}动态类型 逃逸package main  import ＂fmt＂  func main() { 	name := ＂devhui＂ 	fmt.Println(name) }  //# command-line-arguments //./escape_02.go:7:13: inlining call to fmt.Println //./escape_02.go:7:13: name escapes to heap //./escape_02.go:7:13: []interface {}{...} does not escape //:1: leaking param content: .this
　　很多函数的参数为interface{} 空接口类型，这些都会造成逃逸。比如func Printf(format string, a ...interface{}) (n int, err error) func Sprintf(format string, a ...interface{}) string func Fprint(w io.Writer, a ...interface{}) (n int, err error) func Print(a ...interface{}) (n int, err error) func Println(a ...interface{}) (n int, err error) 复制代码
　　编译期间很难确定其参数的具体类型，也能产生逃逸func main() { 	fmt.Println(＂hello 逃逸＂) } /* 逃逸日志分析 ./main.go:5:6: can inline main ./main.go:6:13: inlining call to fmt.Println ./main.go:6:14: ＂hello 逃逸＂ escapes to heap ./main.go:6:13: []interface {} literal does not escape */ 栈空间不足逃逸package main  func main() { 	s := make([]int, 1000, 1000) 	for index, _ := range s { 		s[index] = index  	s1 := make([]int, 10000, 10000) 	for index, _ := range s1 { 		s1[index] = index 	} }
　　逃逸分析：./escape_03.go:4:11: make([]int, 1000, 1000) does not escape ./escape_03.go:9:12: make([]int, 10000, 10000) escapes to heap
　　s足够在栈空间分配没有逃逸；s1空间不够在栈内分配发生了逃逸。变量大小不确定（如 slice 长度或容量不定）package main  func main() { 	s := make([]int, 0, 1000) 	for index, _ := range s { 		s[index] = index 	}  	num := 1000 	s1 := make([]int, 0, num) 	for index, _ := range s1 { 		s1[index] = index 	} }
　　逃逸分析：./escape_05.go:4:11: make([]int, 0, 1000) does not escape ./escape_05.go:10:12: make([]int, 0, num) escapes to heap
　　s分配时cap是一个常量没有发生逃逸，s1的cap是一个变量发生了逃逸。闭包func Increase() func() int { 	n := 0 	return func() int { 		n++ 		return n 	} }  func main() { 	in := Increase() 	fmt.Println(in()) // 1 	fmt.Println(in()) // 2 }  //./escape_04.go:6:2: moved to heap: n //./escape_04.go:7:9: func literal escapes to heap //./escape_04.go:7:9: func literal does not escape //./escape_04.go:15:16: int(~R0) escapes to heap //./escape_04.go:15:13: []interface {}{...} does not escape //./escape_04.go:16:16: int(~R0) escapes to heap //./escape_04.go:16:13: []interface {}{...} does not escape //:1: leaking param content: .this 4. 如何减少逃逸局部切片尽可能确定长度或容量benchmark testimport ＂testing＂  // sliceEscape 发生逃逸，在堆上申请切片 func sliceEscape() { 	number := 10 	s1 := make([]int, 0, number) 	for i := 0; i < number; i++ { 		s1 = append(s1, i) 	} }  // sliceNoEscape 不逃逸，限制在栈上 func sliceNoEscape() { 	s1 := make([]int, 0, 10) 	for i := 0; i < 10; i++ { 		s1 = append(s1, i) 	} }  func BenchmarkSliceEscape(b *testing.B) { 	for i := 0; i < b.N; i++ { 		sliceEscape() 	} }  func BenchmarkSliceNoEscape(b *testing.B) { 	for i := 0; i < b.N; i++ { 		sliceNoEscape() 	} } 测试结果：BenchmarkSliceEscape BenchmarkSliceEscape-10      	53271513	        22.09 ns/op BenchmarkSliceNoEscape BenchmarkSliceNoEscape-10    	187033111	         6.458 ns/op 合理选择返回值、返回指针返回指针可以避免值的拷贝，但是会导致内存分配逃逸到堆中，增加GC的负担。一般情况下，对于需要修改原对象，或占用内存比较大的对象，返回指针。对于只读或占用内存较小的对象，返回值能够获得更好的性能。benchmark testpackage escape_bench_02  import ＂testing＂  type St struct { 	arr [100]int }  func retValue() St { 	var st St 	return st }  func retPtr() *St { 	var st St 	return &st }  func BenchmarkRetValue(b *testing.B) { 	for i := 0; i < b.N; i++ { 		_ = retValue() 	} }  func BenchmarkRetPtr(b *testing.B) { 	for i := 0; i < b.N; i++ { 		_ = retPtr() 	} } 测试结果BenchmarkRetValue-10            34714424                34.45 ns/op            0 B/op          0 allocs/op BenchmarkRetPtr-10               8038676               145.3 ns/op           896 B/op          1 allocs/op
　　可以看到返回值更快且没有发生堆内存的分配。小的拷贝好过引用benchmark testpackage escape_bench_03  import ＂testing＂  const capacity = 1024  func arrayFibonacci() [capacity]int { 	var d [capacity]int 	for i := 0; i < len(d); i++ { 		if i <= 1 { 			d[i] = 1 			continue 		} 		d[i] = d[i-1] + d[i-2] 	} 	return d }  func sliceFibonacci() []int { 	d := make([]int, capacity) 	for i := 0; i < len(d); i++ { 		if i <= 1 { 			d[i] = 1 			continue 		} 		d[i] = d[i-1] + d[i-2] 	} 	return d }  func BenchmarkArray(b *testing.B) { 	for i := 0; i < b.N; i++ { 		_ = arrayFibonacci() 	} }  func BenchmarkSlice(b *testing.B) { 	for i := 0; i < b.N; i++ { 		_ = sliceFibonacci() 	} } 测试结果：BenchmarkArray-10         346110              2986 ns/op               0 B/op          0 allocs/op BenchmarkSlice-10         389745              2849 ns/op            8192 B/op          1 allocs/op
　　那么多大的变量才算是小变量呢？ 对 Go 编译器而言，超过一定大小的局部变量将逃逸到堆上，不同 Go 版本的大小限制可能不一样。一般是 < 64KB，局部变量将不会逃逸到堆上。返回值使用确定的类型benchmark testpackage escape_bench_04  import ＂testing＂  const capacity = 1024  func returnArray() [capacity]int { 	var arr [capacity]int 	for i := 0; i < len(arr); i++ { 		arr[i] = 1000 	} 	return arr }  func returnInterface() interface{} { 	var arr [capacity]int 	for i := 0; i < len(arr); i++ { 		arr[i] = 1000 	} 	return arr }  func BenchmarkReturnArray(b *testing.B) { 	for i := 0; i < b.N; i++ { 		_ = returnArray() 	} }  func BenchmarkReturnInterface(b *testing.B) { 	for i := 0; i < b.N; i++ { 		_ = returnInterface() 	} } 测试结果