浅析Golang中的内存逃逸
目录
- 什么是内存逃逸分析
- 为什么需要逃逸分析
- 如果变量放错了位置会怎样
- 内存逃逸场景
- return 局部变量的指针
- interface{} 动态类型
- 栈空间不足
- 闭包
- 性能
- 最后
什么是内存逃逸分析
内存逃逸分析是go的编译器在编译期间,根据变量的类型和作用域,确定变量是堆上还是栈上
简单说就是编译器在编译期间,对代码进行分析,确定变量分配内存的位置。如果变量需要分配在堆上,则称作内存逃逸了。
为什么需要逃逸分析
因为go语言是自动自动内存管理的,也就是有GC的。开发者在写代码的时候不需要关心考虑内存释放的问题,这样编译器和go运行时(runtime)就需要准确分配和管理内存,所以编译器在编译期间要确定变量是放在堆空间和栈空间。
如果变量放错了位置会怎样
我们知道,栈空间和生命周期是和函数生命周期相关的,如果一个函数的局部变量离开了函数的范围,比如函数结束时,局部变量就会失效。所以要把这样的变量放到堆空间上。
既然如此,那把所有在变量都放在堆上不就行了,这样一来,是没啥问题了,但是堆内存的使用成本比占内存要高好多。使用堆内存,要向操作系统申请和归还,而占内存是程序运行时就确定好了,如何使用完全由程序自己确定。在栈上分配和回收内存成本很低,只需要 2 个 CPU 指令:PUSH 和 POP,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内存逃逸的资料请关注我们其它相关文章!
精彩评论