开发者

浅析Golang中的内存逃逸

目录
  • 什么是内存逃逸分析
  • 为什么需要逃逸分析
    • 如果变量放错了位置会怎样
  • 内存逃逸场景
    • return 局部变量的指针
    • interface{} 动态类型
    • 栈空间不足
    • 闭包
  • 性能
    • 最后

      什么是内存逃逸分析

      内存逃逸分析是go的编译器在编译期间,根据变量的类型和作用域,确定变量是堆上还是栈上

      简单说就是编译器在编译期间,对代码进行分析,确定变量分配内存的位置。如果变量需要分配在堆上,则称作内存逃逸了。

      为什么需要逃逸分析

      因为go语言是自动自动内存管理的,也就是有GC的。开发者在写代码的时候不需要关心考虑内存释放的问题,这样编译器和go运行时(runtime)就需要准确分配和管理内存,所以编译器在编译期间要确定变量是放在堆空间和栈空间。

      如果变量放错了位置会怎样

      我们知道,栈空间和生命周期是和函数生命周期相关的,如果一个函数的局部变量离开了函数的范围,比如函数结束时,局部变量就会失效。所以要把这样的变量放到堆空间上。

      既然如此,那把所有在变量都放在堆上不就行了,这样一来,是没啥问题了,但是堆内存的使用成本比占内存要高好多。使用堆内存,要向操作系统申请和归还,而占内存是程序运行时就确定好了,如何使用完全由程序自己确定。在栈上分配和回收内存成本很低,只需要 2 个 CPU 指令:PUSHPOP,push 将数据放到到栈空间完成分配,pop 则是释放空间。

      比如 C++ 经典错误,return 一个 函数内部变量的指针

      #include<IOStream>
      
      int* one(){
          int i = 10;
          return &i;
      }
      
      int main(){
          std::cout << *one();
      }
      

      这段代码在编译的时候会如下警告:

      one.cpp: 在函数‘int* one()’中:

      one.cpp:4:6: 警告:返回了局部变量的‘i’的地址 [-Wreturn-local-addr]

        int i = 10;

            ^

      虽然程序的运行结果大多数时候都和我们预期的一样,但是这样的代码还是有风险的。

      这样的代码在go里就完全没有问题了,因为go的编译器会根据变量的作用范围确定变量是放在栈上和堆上。

      内存逃逸场景

      go的编译器提供了逃逸分析的工具,只需要在编译的时候加上 -gcflags=-m 就可以看到逃逸分析的结果了

      常见的有4种场景下会出现内存逃逸

      return 局部变量的指针

      package main
      
      func main() {
      
      }
      
      func One() *int {
         i := 10
         return &i
      }
      

      执行 go build -gcflags=-m main.go

      # command-line-arguments
      .\main.go:3:6: can inline main
      .javascript\main.go:7:6: can inline One
      .\main.go:8:2: moved to heap: i
      

      可以看到变量 i 已经被分配到堆上了

      interface{} 动态类型

      当函数传递的变量类型是 interface{} 类型的时候,因为编译器无法推断运行时变量的实际类型,所以也会发生逃逸

      package main
      
      import "fmt"
      
      func main() {
         i := 10
         fmt.Println(i)
      }
      

      执行 go build -gcflags=-m .\main.go

      .\main.go:11:13: inlining call to fmt.Println
      .\main.go:11:13: i escapes to heap
      .\main.go:11:13: []interface {} literal does not escape
      <autogenerated>:1: .this does not escape
      <autogenerated>:1: .this does not escape
      

      可看到,i 也被分配到栈上了

      栈空间不足

      因为栈的空间是有限的,所以在分配大块内存时,会考虑栈空间内否存下,如果栈空间存不下,会分配到堆上。

      package mai开发者_JS教程n
      
      func main() {
         Make10()
         Make100()
         Make10000()
         MakeN(5)
      }
      
      func Make10() {
         arr10 := make([]int, 10)
         _ = arr10
      }
      
      func Make100() {
         arr100 := make([]int, 100)
         _ = arr100
      }
      
      func Make10000() {
         arr10000 := make([]int, 10000)
         _ = arr10000
      }
      
      func MakeN(n int) {
         arrN := make([]int, n)
         _ = aandroidrrN
      }
      

      执行 go build -gcflags=-m main.go

      # command-line-arguments
      .\main.go:10:6: can inline Make10
      .\main.go:15:6: can inline Make100
      .\main.go:20:6: can inline Make10000
      .\main.go:25:6: can inline MakeN
      .\main.go:3:6: can inline main
      .\main.go:4:8: inlining call to Make10
      .\main.go:5:9: inlining call to Make100
      .\main.go:6:11: inlining call to Make10000
      .\main.go:7:7: inlining call to MakeN
      .\main.go:4:8: make([]int, 10) does not escape
      .\main.go:5:9: make([]int, 100) does not escape
      .\main.go:6:11: make([]int, 10000) escapes to heap
      .\main.go:7:7: make([]int, n) escapes to heap
      .\main.go:11:15: make([]int, 10) does not escape
      .\main.go:16:16: make([]int, 100) d编程客栈oes not escape
      .\main.go:21:18: make([]int, 10000) escapes to heap
      .\main.go:26:14: make([]int, n) escapes to heap
      

      可以看到当需要分配长度为10,100的int类型的slice时,不需要逃逸到堆上,在栈上就可以,如果slice长度达到1000时,就需要分配到堆上了。

      还有一种情况,当在编译期间长度不确定时,也需要分配到堆上。

      闭包

      package main
      
      func main() {
         One()
      }
      
      func One() func() {
         n := 10
         return func() {
            n++
         }
      }
      

      在函数One中return了一个匿名函数,形成了一个闭包,看一下逃逸分析

      # command-line-arguments
      .\main.go:3:6: can inline main
      .\main.go:9:9: can inline One.func1
      .\main.go:8:2: moved to heap: n
      .\main.go:9:9: func literal escapes to heap
      

      可以看到 变量 n 也分配到堆上了

      还有一种情况,new 出来的变量不一定分配到堆上

      package main
      
      func main() {
         i := new(int)
         _ = i
      }
      

      像Java C++等语言,new 出来的变量正常都会分配到堆上,但是在go里,new出来的变量不一定分配到堆上,至于分配到哪里,还是看编译器的逃逸分析来确定

      编译一下看看 go build -gcflags=-m main.go

      # command-line-arguments
      .\main.go:3:6: can inline main
      .\mainphp.go:4:10: new(int) does not escape
      

      可以看到 new出来的变量,并没有逃逸,还是在栈上。

      常见的内存逃逸场景差不多就是这些了,再说一下内存逃逸带来的影响吧

      性能

      那肯定就是性能问题了,因为操作栈空间比堆空间要快多了,而且使用堆空间还会有GC问题,频繁的创建和释放堆空间,会增加GC的压力

      一个简单的例子测试一下,一般来说,函数返回结构体的指针比直接返回结构体性能要好

      package main
      
      import "testing"
      
      type MyStruct struct {
         A int
      }
      
      func BenchmarkOne(b *testing.B) {
         for i := 0; i < b.N; i++ {
            One()
         }
      }
      
      //go:noinline
      func One() MyStruct {
         return MyStruct{
            A: 10,
         }
      }
      
      func BenchmarkTwo(b *testing.B) {
         for i := 0; i < b.N; i++ {
            Two()
         }
      }
      
      //go:noinline
      func Two() *MyStruct {
         return &MyStruct{
            A: 10,
         }
      }
      

      注意 被调用的函数一定要加上 //go:noinline 来禁止编译器内联优化

      然后执行

      go test -bench . -benchmem

      goos: Windows
      goarch: amd6android4
      pkg: escape
      BenchmarkOne-6          951519297                1.26 ns/op            0 B/op          0 allocs/op
      BenchmarkTwo-6          74933496                15.4 ns/op             8 B/op          1 allocs/op
      PASS
      ok      escape  2.698s
      

      可以明显看到 函数 One返回结构体 比 函数Two 返回 结构体指针 的性能更好,而且还不会有内存分配,不会增加GC压力

      抛开结构体的大小谈性能都是耍流氓,如果结构体比较复杂了还是指针性能更高,还有一些场景必须使用指针,所以实际工作中还是要分场景合理使用

      最后

      常见的go 逃逸分析差不多就是这些了,虽然go会自动管理内存,减小了写代码的负担,但是想要写出高效可靠的代码还是有一些细节有注意的。

      以上就是浅析golang中的内存逃逸的详细内容,更多关于Golang内存逃逸的资料请关注我们其它相关文章!

      0

      上一篇:

      下一篇:

      精彩评论

      暂无评论...
      验证码 换一张
      取 消

      最新开发

      开发排行榜