浅析Golang中的内存逃逸

更新时间：2022年10月16日 15:06:00 作者：紫葡萄

内存逃逸分析是go的编译器在编译期间，根据变量的类型和作用域，确定变量是堆上还是栈上。本文将通过示例浅析一下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: 在函数‘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
.\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会自动管理内存，减小了写代码的负担，但是想要写出高效可靠的代码还是有一些细节有注意的。

以上就是浅析Golang中的内存逃逸的详细内容，更多关于Golang内存逃逸的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

go语言中的Carbon库时间处理技巧
这篇文章主要介绍了go语言中的Carbon库时间处理,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-02-02
一文教你学会Go中singleflight的使用
缓存在项目中使用应该是非常频繁的,提到缓存只要了解过 singleflight ,基本都会用于缓存实现的一部分吧,下面就跟随小编一起来学习一下singleflight的使用吧
2024-02-02
golang逐行读取文件的操作
这篇文章主要介绍了golang逐行读取文件的操作，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2020-12-12
GoLang分布式锁与snowflake雪花算法
这篇文章主要介绍了GoLang分布式锁与snowflake雪花算法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2022-12-12
GoLang基础学习之go test测试
相信每位编程开发者们应该都知道,Golang作为一门标榜工程化的语言,提供了非常简便、实用的编写单元测试的能力,下面这篇文章主要给大家介绍了关于GoLang基础学习之go test测试的相关资料,需要的朋友可以参考下
2022-08-08
Golang实现web文件共享服务的示例代码
这篇文章主要介绍了Golang实现web文件共享服务的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-10-10
一文详解Golang中的匿名变量
匿名变量是一种特殊类型的变量,可以简化代码并提高可读性,本文将为大家详细介绍一下golang中匿名变量的定义、特性和使用方法,需要的可以参考下
2023-09-09
Golang中切片的用法与本质详解
Go的切片类型为处理同类型数据序列提供一个方便而高效的方式，下面这篇文章就来给大家介绍了关于Golang中切片的用法与本质的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考下
2018-07-07
Go语言如何并发超时处理详解
大家都知道golang并没有在语言层次上提供超时操作，但可以通过一些小技巧实现超时。下面来一起看看吧，有需要的朋友们可以参考借鉴。
2016-09-09
4个场景教会你Go中Goroutine和通道是怎么用的
本篇给出了4个在运维开发工作中较为常见的且也是比较典型的场景，通过这些场景来带大家掌握Go中Goroutine和通道是怎么使用的，需要的可以学习一下
2023-05-05