什么是内存逃逸,在什么情况下发生,原理是什么?
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(){
}