浅析Golang中的内存逃逸

作者:紫葡萄 时间:2024-05-05 09:28:21 

什么是内存逃逸分析

内存逃逸分析是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: 在函数&lsquo;int* one()&rsquo;中:
one.cpp:4:6: 警告:返回了局部变量的&lsquo;i&rsquo;的地址 [-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
.\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 main

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)
  _ = arrN
}

执行 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) does 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
.\main.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: amd64
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会自动管理内存,减小了写代码的负担,但是想要写出高效可靠的代码还是有一些细节有注意的。

来源:https://juejin.cn/post/7154711508142784526

标签:Golang,内存,逃逸
0
投稿

猜你喜欢

  • 基于Python组装jmx并调用JMeter实现压力测试

    2023-05-03 04:42:20
  • 设计"以人为本"和"绿色设计"

    2008-10-07 12:21:00
  • 语义化你的HTML标签和属性

    2008-06-12 13:18:00
  • JavaScript数据结构和算法之图和图算法

    2024-05-03 15:32:34
  • Python变量基础知识

    2021-10-11 02:13:12
  • Oracle 插入超4000字节的CLOB字段的处理方法

    2009-07-12 18:52:00
  • 2022最新腾讯轻量云 debian 10 安装pve教程详解

    2022-09-16 15:55:38
  • tensorflow模型的save与restore,及checkpoint中读取变量方式

    2022-07-27 17:41:43
  • 跨浏览器的CSS固定定位{position:fixed}

    2007-05-11 16:50:00
  • 如何在python中使用selenium的示例

    2023-07-15 20:52:09
  • vue中项目页面空白但不报错产生的原因及分析

    2024-05-03 15:12:17
  • vscode 配置eslint和prettier正确方法

    2022-12-31 04:54:44
  • 解决Pyinstaller 打包exe文件 取消dos窗口(黑框框)的问题

    2023-09-27 10:32:31
  • 亲自教你使用 ChatGPT 编写 SQL JOIN 查询示例

    2024-01-14 18:54:01
  • IE6,IE7中定位相关的怪异问题

    2009-12-08 12:49:00
  • MySQL命令行中给表添加一个字段(字段名、是否为空、默认值)

    2024-01-16 12:47:36
  • PWA介绍及快速上手搭建一个PWA应用的方法

    2024-04-19 09:56:33
  • Python 结巴分词实现关键词抽取分析

    2023-08-13 08:20:06
  • Go语言基于Socket编写服务器端与客户端通信的实例

    2023-07-12 08:44:11
  • PHP函数原理理解详谈

    2023-06-04 01:56:59
  • asp之家 网络编程 m.aspxhome.com