Java教程

内存逃逸分析

本文主要是介绍内存逃逸分析,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

问题

知道golang的内存逃逸吗?什么情况下会发生内存逃逸?

怎么答

因为函数都是运行在栈上的,在栈声明临时变量分配内存,函数运行完毕再回收该段栈空间,并且每个函数的栈空间都是独立的,其他代码都是不可访问的。但是在某些情况下,栈上的空间需要在
该函数被释放后依旧能访问到,这时候就涉及到内存的逃逸了。

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

  1. 在方法内把局部变量指针返回 局部变量原本应该在栈中分配,在栈中回收。但是由于返回时被外部引用,因此其生命周期大于栈,则溢出。
      type S struct {
      s string
      }
    
      func getS(str string) *S {
          return &S{str}
      }
      a := getS("hello")
      b := a.s + " world"
      c := b + "!"
      fmt.Println(c)
    
    执行go build -gcflags=-m main.go
    ./main.go:11:6: can inline getS
    ./main.go:16:11: inlining call to getS
    ./main.go:19:13: inlining call to fmt.Println
    ./main.go:11:11: leaking param: str
    ./main.go:12:9: &S literal escapes to heap     局部变量return逃逸 符合情况
    ./main.go:16:11: &S literal does not escape    这里是a拿到了&S 局部变量 不逃逸
    ./main.go:17:11: a.s + " world" does not escape 局部变量不逃逸
    ./main.go:18:9: b + "!" escapes to heap  c变量逃逸
    ./main.go:19:13: c escapes to heap  
    ./main.go:19:13: []interface {} literal does not escape
    
  2. 发送指针或带有指针的值到 channel 中。 在编译时,是没有办法知道哪个 goroutine 会在 channel 上接收数据。所以编译器没法知道变量什么时候才会被释放。
    ch := make(chan *int, 1)
    a := 10
    b := &a
    go func() {
        ch <- b
    }()
    go func() {
        select {
        case <-ch:
            return
        default:
        }
    }()
    time.Sleep(2 * time.Second)
    
    执行go build -gcflags=-m main.go
    ./main.go:22:5: can inline main.func1
    ./main.go:20:2: moved to heap: a
    ./main.go:22:5: func literal escapes to heap
    ./main.go:25:5: func literal escapes to heap
    
  3. 在一个切片上存储指针或带指针的值。 一个典型的例子就是 []*string 。这会导致切片的内容逃逸。尽管其后面的数组可能是在栈上分配的,但其引用的值一定是在堆上
     s := make([]*string, 10)
     a := "aaaaaa"
     s[0] = &a
    
    执行go build -gcflags=-m main.go
    ./main.go:11:6: can inline main
    ./main.go:33:2: moved to heap: a  变量发生逃逸
    ./main.go:32:11: make([]*string, 10) does not escape
    
  4. slice 的背后数组被重新分配了,因为 append 时可能会超出其容量( cap )。 slice 初始化的地方在编译时是可以知道的,它最开始会在栈上分配。如果切片背后的存储要基于运行时的数据进行扩充,就会在堆上分配。
  5. 在 interface 类型上调用方法。 在 interface 类型上调用方法都是动态调度的 —— 方法的真正实现只能在运行时知道。想像一个 io.Reader 类型的变量 r , 调用 r.Read(b) 会使得 r 的值和切片b 的背后存储都逃逸掉,所以会在堆上分配。
这篇关于内存逃逸分析的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!