go 内存逃逸示例

什么是内存逃逸，在什么情况下发生，原理是什么?

golang程序变量会携带有一组校验数据，用来证明它的整个生命周期是否在运行时完全可知。如果变量通过了这些校验，它就可以在栈上分配。否则就说它 逃逸 了，必须在堆上分配。

能引起变量逃逸到堆上的典型情况：

在方法内把局部变量指针返回 局部变量原本应该在栈中分配，在栈中回收。但是由于返回时被外部引用，因此其生命周期大于栈，则溢出。
发送指针或带有指针的值到 channel 中。 在编译时，是没有办法知道哪个 goroutine 会在 channel 上接收数据。所以编译器没法知道变量什么时候才会被释放。
在一个切片上存储指针或带指针的值。 一个典型的例子就是 []*string 。这会导致切片的内容逃逸。尽管其后面的数组可能是在栈上分配的，但其引用的值一定是在堆上。
slice 的背后数组被重新分配了，因为 append 时可能会超出其容量( cap )。 slice 初始化的地方在编译时是可以知道的，它最开始会在栈上分配。如果切片背后的存储要基于运行时的数据进行扩充，就会在堆上分配。
在 interface 类型上调用方法。 在 interface 类型上调用方法都是动态调度的 —— 方法的真正实现只能在运行时知道。想像一个 io.Reader 类型的变量 r , 调用 r.Read(b) 会使得 r 的值和切片b 的背后存储都逃逸掉，所以会在堆上分配。

如何避免内存逃逸

• 对于小型的数据，使用传值而不是传指针，避免内存逃逸。 避免使用长度不固定的slice切片，在
• 编译期无法确定切片长度，只能将切片使用堆分配。
• interface调用方法会发生内存逃逸，在热点代码片段，谨慎使用。

示例

package main

import "time"

type(
	Foo struct{
		A int
		B string
	}
	FooHasPointer struct{
		A  *int
		B string
	}
)

// 返回了指向了内书内部变量a的指针，a逃逸到堆上
func escapeValue() *int{
	var a int //mobed to heap:a
	a = 1
	return &a
}

//函数内部变量会被分配到stack上，即使它是一个指针变量
func noescapeNew(){
	newa:=new(int) //noescapeNew new(int) does not escape
	*newa = 1
}

//指向i的指针被存储到foo结构体中返回了，i逃逸到heap上
func escapePointer() FooHasPointer{
	var foo FooHasPointer
	i := 10 //mobed to heap:i
	foo.A = &i 
	foo.B = "a" //todo if not this line
	return foo
}

//none pointer. all delivery to stack
func noescapeValue()Foo{
	var foo Foo
	i:=10
	foo.A = i
	foo.B = "a"
	return foo
}


// 发送指针或带有指针的值到 channel 中。 
// 在编译时，是没有办法知道哪个 goroutine 会在 channel 上接收数据。
// 所以编译器没法知道变量什么时候才会被释放。
func escapeChannel(){
	var ch = make(chan * int,1)
	var a = 10 //escape
	var b= &a 
	go func(){
		ch <- b
	}()
	go func(){
		select{
		case <- ch:
			return
		default:
		}
	}()
	time.Sleep(2*time.Second)
}


func noescapeChannel(){
	var ch = make(chan  int,1) //not a * int 
	var a = 10 //no escape
	var b= a 
	go func(){
		ch <- b
	}()
	go func(){
		select{
		case <- ch:
			return
		default:
		}
	}()
	time.Sleep(2*time.Second)
}

// 在一个切片上存储指针或带指针的值。 一个典型的例子就是 []*string 。这会导致切片的内容逃逸。
// 尽管其后面的数组可能是在栈上分配的，但其引用的值一定是在堆上
func escapeString(){
	s := make([]*string,10) //does not escape
	a:="aaa" //escape a
	s[0] = &a
}

//在 interface 类型上调用方法。 在 interface 类型上调用方法都是动态调度的 —— 方法的真正实现只能在运行时知道。
// 想像一个 io.Reader 类型的变量 r , 调用 r.Read(b) 会使得 r 的值和切片b 的背后存储都逃逸掉，所以会在堆上分配。

func main(){

}