这篇文章主要讲解了“Golang中的内存逃逸怎么应用”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Golang中的内存逃逸怎么应用”吧！

什么是内存逃逸分析

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

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

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

内存逃逸场景

-gcflags=-m

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

return 局部变量的指针

package mainfunc 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 mainimport "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 mainfunc 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 mainfunc main() {   One()}func One() func() {   n := 10   return func() {      n++   }}
One
# 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 mainfunc 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 mainimport "testing"type MyStruct struct {   A int}func BenchmarkOne(b *testing.B) {   for i := 0; i < b.N; i++ {      One()   }}//go:noinlinefunc One() MyStruct {   return MyStruct{      A: 10,   }}func BenchmarkTwo(b *testing.B) {   for i := 0; i < b.N; i++ {      Two()   }}//go:noinlinefunc Two() *MyStruct {   return &MyStruct{      A: 10,   }}
//go:noinline

然后执行

go test -bench . -benchmem
goos: windowsgoarch: amd64pkg: escapeBenchmarkOne-6          951519297                1.26 ns/op            0 B/op          0 allocs/opBenchmarkTwo-6          74933496                15.4 ns/op             8 B/op          1 allocs/opPASSok      escape  2.698s
OneTwo

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

感谢各位的阅读，以上就是“Golang中的内存逃逸怎么应用”的内容了，经过本文的学习后，相信大家对Golang中的内存逃逸怎么应用这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是匠子博客园，小编将为大家推送更多相关知识点的文章，欢迎关注！