您现在的位置是:首页 > Golang技术干货

聊聊内存逃逸

Golang技术干货作者:chenli日期:2021-08-31 11:17:10点击:149

什么是内存逃逸

在程序中,每个函数块都会有自己的内存区域用来存自己的局部变量(内存占用少)、返回地址、返回值之类的数据,这一块内存区域有特定的结构和寻址方式,寻址起来十分迅速,开销很少。这一块内存地址称为栈。栈是线程级别的,大小在创建的时候已经确定,当变量太大的时候,会”逃逸”到堆上,这种现象称为内存逃逸。简单来说,局部变量通过堆分配和回收,就叫内存逃逸。

内存逃逸的危害

堆是一块没有特定结构,也没有固定大小的内存区域,可以根据需要进行调整。全局变量,内存占用较大的局部变量,函数调用结束后不能立刻回收的局部变量都会存在堆里面。变量在堆上的分配和回收都比在栈上开销大的多。对于 go 这种带 GC 的语言来说,会增加 gc 压力,同时也容易造成内存碎片。

如何分析程序是否发生内存逃逸

build时添加-gcflags=-m 选项可分析内存逃逸情况,比如输出./main.go:3:6: moved to heap: x 表示局部变量x逃逸到了堆上。

内存逃逸发生时机

1.向 channel 发送指针数据。因为在编译时,不知道channel中的数据会被哪个 goroutine 接收,因此编译器没法知道变量什么时候才会被释放,因此只能放入堆中。

  1. package main
  2. func main() {
  3. ch := make(chan int, 1)
  4. x := 5
  5. ch <- x // x不发生逃逸,因为只是复制的值
  6. ch1 := make(chan *int, 1)
  7. y := 5
  8. py := &y
  9. ch1 <- py // y逃逸,因为y地址传入了chan中,编译时无法确定什么时候会被接收,所以也无法在函数返回后回收y
  10. }

2.局部变量在函数调用结束后还被其他地方使用,比如函数返回局部变量指针或闭包中引用包外的值。因为变量的生命周期可能会超过函数周期,因此只能放入堆中。

  1. package main
  2. func Foo () func (){
  3. x := 5 // x发生逃逸,因为在Foo调用完成后,被闭包函数用到,还不能回收,只能放到堆上存放
  4. return func () {
  5. x += 1
  6. }
  7. }
  8. func main() {
  9. inner := Foo()
  10. inner()
  11. }

3.在 slice 或 map 中存储指针。比如 []*string,其后面的数组可能是在栈上分配的,但其引用的值还是在堆上。

  1. package main
  2. func main() {
  3. var x int
  4. x = 10
  5. var ls []*int
  6. ls = append(ls, &x) // x发生逃逸,ls存储的是指针,所以ls底层的数组虽然在栈存储,但x本身却是逃逸到堆上
  7. }

4.切片扩容后长度太大,导致栈空间不足,逃逸到堆上。

  1. package main
  2. func main() {
  3. s := make([]int, 10000, 10000)
  4. for index, _ := range s {
  5. s[index] = index
  6. }
  7. }

5.在 interface 类型上调用方法。 在 interface 类型上调用方法时会把interface变量使用堆分配, 因为方法的真正实现只能在运行时知道。

  1. package main
  2. type foo interface {
  3. fooFunc()
  4. }
  5. type foo1 struct{}
  6. func (f1 foo1) fooFunc() {}
  7. func main() {
  8. var f foo
  9. f = foo1{}
  10. f.fooFunc() // 调用方法时,f发生逃逸,因为方法是动态分配的
  11. }

避免内存逃逸的办法

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

文章评论