内存分配，逃逸分析深入理解-Go-带代码演示

快进到失业

于 2024-09-29 23:11:01 发布

阅读量352

点赞数 17

分类专栏： golang 文章标签： golang 内存分配逃逸分析堆和栈

本文链接：https://blog.csdn.net/weixin_45863010/article/details/142645227

版权

golang 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

内存管理
栈
堆
堆和栈的对比
逃逸分析
代码演示
如何使用逃逸分析写出更优雅的代码
参考链接

在Go中内存分配既可以分配到堆中，也可以分配到栈中。什么样的数据会被分配到栈中，什么样的数据又会被分配到堆中呢？

内存管理

内存管理主要包括两个动作：分配与释放。逃逸分析就是服务于内存分配。

栈

在Go中，栈的内存是由编译器自动进行分配和释放，栈区往往存储着函数参数、局部变量和调用函数帧，它们随着函数的创建而分配，函数的退出而销毁。

一个goroutine对应一个栈，栈是调用栈（call stack）的简称。一个栈通常又包含了许多栈帧（stack frame），它描述的是函数之间的调用关系，每一帧对应一个尚未返回的函数调用，它本身也是以栈形式存放数据。

堆

与栈不同的是，应用程序在运行时只会存在一个堆。

我们可以简单理解为：我们用GO语言开发过程中，要考虑的内存管理只是针对堆内存而言的。

程序在运行期间可以主动从堆上申请内存，这些内存通过Go的内存分配器分配，并由垃圾收集器回收。

堆和栈的对比

加锁

栈不需要加锁：栈是每个goroutine独有的，这就意味着栈上的内存操作是不需要加锁的。
堆有时需要加锁：堆上的内存，有时需要加锁防止多线程冲突

延伸知识点：为什么堆上的内存有时需要加锁？而不是一直需要加锁呢？
因为Go的内存分配策略学习了TCMalloc的线程缓存思想，他为每个处理器P分配了一个mcache，从mcache分配内存也是无锁的
tcmalloc全称Thread-Caching Malloc，即线程缓存的malloc，实现了高效的多线程内存管理，用于替代系统的内存分配相关的函数（malloc、free，new，new[]等）。

性能

栈内存管理性能好：栈上的内存，它的分配与释放非常高效的。简单地说，它只需要两个CPU指令：一个是分配入栈，另外一个是栈内释放。只需要借助于栈相关寄存器即可完成。
堆内存管理性能差：对于程序堆上的内存回收，还需要通过标记清除阶段，例如Go采用的三色标记法。

缓存策略

栈缓存性能更好
堆缓存性能较差
原因是：栈内存能更好地利用CPU的缓存策略，因为栈空间相较于堆来说是更连续的。

逃逸分析

上面说了这么多堆和栈的知识点，目的是为了让大家更好的理解逃逸分析。

正如上面讲的，相比于把内存分配到堆中，分配到栈中优势更明显。 Go语言也是这么做的：

Go编译器会尽可能将变量分配到到栈上。
当编译器无法证明函数返回的变量有没有被引用时，编译器就必须在堆上分配该变量，以此避免悬挂指针（dangling pointer）的问题。
如果局部变量占用内存非常大，也会将其分配在堆上。

Go是如何确定内存是分配到栈上还是堆上的呢？
答案就是：逃逸分析。

编译器通过逃逸分析技术去选择堆或者栈，逃逸分析的基本思想如下：

检查变量的生命周期是否是完全可知的，如果通过检查，则在栈上分配。
否则，就是所谓的逃逸，必须在堆上进行分配。

逃逸分析原则
Go语言虽然没有明确说明逃逸分析原则，但是有以下几点准则，是可以参考的。

不同于JAVA JVM的运行时逃逸分析，Go的逃逸分析是在编译期完成的：编译期无法确定的参数类型必定放到堆中；
如果变量在函数外部存在引用，则必定放在堆中；
如果变量占用内存较大时，则优先放到堆中；
如果变量在函数外部没有引用，则优先放到栈中；

代码演示

我们可以使用这个命令来查看逃逸分析的结果：

go build -gcflags '-m -m -l

interface类型的参数

import (
	"fmt"
)

// 参数是interface{}类型的
func main() {
	a := 10
	fmt.Println(a)
}

结果

wt@wt:~/Backend/go/goprojects/src/golearndetail/performance/mallocStackOrHeap$ go build -gcflags '-m -m -l' demo01.go 
# command-line-arguments
./demo01.go:17:14: a escapes to heap:
./demo01.go:17:14:   flow: {storage for ... argument} = &{storage for a}:
./demo01.go:17:14:     from a (spill) at ./demo01.go:17:14
./demo01.go:17:14:     from ... argument (slice-literal-element) at ./demo01.go:17:13
./demo01.go:17:14:   flow: {heap} = {storage for ... argument}:
./demo01.go:17:14:     from ... argument (spill) at ./demo01.go:17:13
./demo01.go:17:14:     from fmt.Println(... argument...) (call parameter) at ./demo01.go:17:13
./demo01.go:17:13: ... argument does not escape
./demo01.go:17:14: a escapes to heap

查看Println()函数源码可以发现接收参数类型为any(Interface{})，编译期间无法确定其具体的参数类型，所以内存分配到堆中。

// Println formats using the default formats for its operands and writes to standard output.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Println(a ...any) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}

变量在函数外部有引用

代码示例：

package main

func test() *int {
	a := 10
	return &a
}

func main() {
	_ = test()
}

编译结果

wt@wt:~/Backend/go/goprojects/src/golearndetail/performance/mallocStackOrHeap$ go build -gcflags '-m -m -l' demo02.go 
# command-line-arguments
./demo02.go:11:2: a escapes to heap:
./demo02.go:11:2:   flow: ~r0 = &a:
./demo02.go:11:2:     from &a (address-of) at ./demo02.go:12:9
./demo02.go:11:2:     from return &a (return) at ./demo02.go:12:2
./demo02.go:11:2: moved to heap: a

变量a在函数外部存在引用。

分析：当函数执行完毕，对应的栈帧就被销毁，但是引用已经被返回到函数之外。如果这时外部通过引用地址取值，虽然地址还在，但是这块内存已经被释放回收了，这就是非法内存。为了避免上述非法内存的情况，在这种情况下变量的内存分配必须分配到堆上。

变量内存占用较大

代码演示：

package main

func test01() {
	a := make([]int, 10000, 10000)
	for i := 0; i < 10000; i++ {
		a[i] = i
	}
}

func main() {
	test01()
}

编译结果

wt@wt:~/Backend/go/goprojects/src/golearndetail/performance/mallocStackOrHeap$ go build -gcflags '-m -m -l' demo03.go 
# command-line-arguments
./demo03.go:11:11: make([]int, 10000, 10000) escapes to heap:
./demo03.go:11:11:   flow: {heap} = &{storage for make([]int, 10000, 10000)}:
./demo03.go:11:11:     from make([]int, 10000, 10000) (too large for stack) at ./demo03.go:11:11
./demo03.go:11:11: make([]int, 10000, 10000) escapes to heap

定义了一个容量为10000的int类型切片，发生了逃逸，内存分配到了堆上（heap）。
将将切片的容量和长度修改为1，再次查看逃逸分析的结果，我们发现，没有发生逃逸，内存默认分类到了栈上。

package main

func test01() {
	a := make([]int, 1, 1)
	for i := 0; i < 1; i++ {
		a[i] = i
	}
}

func main() {
	test01()
}
===========================================================================
wt@wt:~/Backend/go/goprojects/src/golearndetail/performance/mallocStackOrHeap$ go build -gcflags '-m -m -l' demo03.go 
# command-line-arguments
./demo03.go:11:11: make([]int, 1, 1) does not escape

变量大小不确定

修改演示代码如下：

package main

func test01() {
	l := 1
	a := make([]int, l, l)
	for i := 0; i < l; i++ {
		a[i] = i
	}
}

func main() {
	test01()
}

编译执行结果：

wt@wt:~/Backend/go/goprojects/src/golearndetail/performance/mallocStackOrHeap$ go build -gcflags '-m -m -l' demo03.go 
# command-line-arguments
./demo03.go:12:11: make([]int, l, l) escapes to heap:
./demo03.go:12:11:   flow: {heap} = &{storage for make([]int, l, l)}:
./demo03.go:12:11:     from make([]int, l, l) (non-constant size) at ./demo03.go:12:11
./demo03.go:12:11: make([]int, l, l) escapes to heap