系列导读
本文为《Go语言轻松进阶》系列第二章「内存与垃圾回收」的第三小节。第二章目录:
查看本系列完整内容请访问
本文导读本文将从6个方向层层递进,帮助大家彻底理解Go语言的栈内存和堆内存:
计算机为什么需要内存?计算机是运行自动化程序的载体,程序(或称之为进程)由可执行代码被执行后产生。那么计算机在运行程序的过程中为什么需要「内存」呢?为了轻松理解这个问题,我们先来简单看看:
代码的本质简单来看代码主要包含两部分:
代码包含了指令,代码被转化为可执行二进制文件,被执行后加载到内存中,中央处理器CPU通过内存获取指令,图示如下: 详细请移步历史文章「回到本真,代码到底是什么?」 程序的运行过程可执行代码文件被执行之后,代码中的待执行指令被加载到了内存当中。这时CPU就可以从内存中获取指令、并执行指令。 CPU执行指令简易过程分为三步:
我们通过一个简易的时序图来看看CPU获取并执行指令的过程: 详细请移步历史文章「回到本真,代码是如何运行的?」 内存的作用通过以上我们可以基本看出「内存」在计算机中扮演的角色:
至此我们基本明白了内存存在的意义。但是呢,我们又经常会听到关于「栈内存」、「堆内存」的概念,那「栈内存」和「堆内存」到底是什么呢?接下来我们继续来看看这个问题。 为什么需要栈内存?程序在使用内存的过程中,不仅仅只需要关注内存的分配问题,还需要关注到内存使用完毕的回收问题,这就是内存管理中面临的最大两个问题:
答:最简单、高效的分配和回收方式就是对一段连续内存的「线性分配」,「栈内存」的分配就采用了这种方式。 「栈内存」的简易管理过程: 1. 栈内存分配逻辑:current - alloc 2. 栈内存释放逻辑:current + alloc 通过利用「栈内存」,CPU在执行指令过程中可以高效地存储临时变量。其次:
所以同时你应该也理解了「为什么称之为栈内存?」。「栈内存」是计算机对连续内存的采取的「线性分配」管理方式,便于高效存储指令运行过程中的临时变量。 为什么需要堆内存?假如函数A内变量是个指针且被函数B外的代码依赖,如果对应变量内存被回收,这个指针就成了野指针不安全。怎么解决这个问题呢? 答:这就是「堆内存」存在的意义,Go语言会在代码编译期间通过「逃逸分析」把分配在「栈」上的变量分配到「堆」上去。
答:堆内存通过「垃圾回收器」回收,关于「垃圾回收器」后续我们详解。 Go语言分配的是虚拟内存通过以上我们了解了「内存」、「栈内存」、「堆内存」存在的意义。除此之外,还有一个重要的知识点:程序和操作系统实际操作的都是虚拟内存,最终由CPU通过内存管理单元MMU(Memory Manage Unit)把虚拟内存的地址转化为实际的物理内存地址。图示如下: 使用虚拟内存的原因:
所以,一个很重要的知识点:
也就是说Go语言源代码中:
接着我们分别通过分配时机、分配过程两部分,来看看Go语言栈内存和堆内存的分配。 Go语言栈内存的分配Go语言栈内存分配的时机
栈内存分配时机-创建 |
类型 | 名称 | 描述 | 代码位置 |
---|---|---|---|
切片 | makeslice(et *_type, len, cap int) unsafe.Pointer | 创建切片 | src/runtime/slice.go::83 |
切片 | growslice(et *_type, old slice, cap int) slice | 切片扩容 | src/runtime/slice.go::125 |
切片 | makeslicecopy(et *_type, tolen int, fromlen int, from unsafe.Pointer) unsafe.Pointer | copy切片 | src/runtime/slice.go::36 |
字节字符串 | gobytes(p *byte, n int) (b []byte) | 转换字符串string 为[]byte 类型 | src/runtime/string.go::301 |
字节字符串 | slicebytetostring(buf *tmpBuf, ptr *byte, n int) (str string) | 转换字节字符串[]byte 为类型string | src/runtime/string.go::80 |
字节字符串 | rawstring(size int) (s string, b []byte) | 按大小初始化一个新的string 类型 | src/runtime/string.go::83 |
字节字符串 | rawbyteslice(size int) (b []byte) | 按大小初始化一个新的[]byte 类型 | src/runtime/string.go::83 |
字节字符串 | rawruneslice(size int) (b []rune) | 按大小初始化一个新的[]rune 类型 | src/runtime/string.go::83 |
Channel | makechan(t *chantype, size int) *hchan | 创建一个chan | src/runtime/chan.go::71 |
数组 | func newarray(typ *_type, n int) unsafe.Pointer | 初始化一个数组 | src/runtime/malloc.go::1191 |
Map | mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer | map申请内存 | src/runtime/map.go::571 |
Map | func (h *hmap) newoverflow(t *maptype, b *bmap) *bmap | map申请溢出桶 | src/runtime/map.go::245 |
等等 | ... | ... |
这里我们以初始化切片的源代码为例来看看切片何时被分配到堆上的逻辑判断:
理论上直接分配到栈内存上
编译器进行逃逸分析,判断并标记该变量是否需要分配到堆上
否:直接分配在栈上
是:调用src/runtime/slice.go::makeslice()
分配到堆上
切片分配过程源代码如下:
// 代码位置:src/cmd/compile/internal/gc/walk.go::1316
// 初始化切片
case OMAKESLICE:
// ...略...
// 逃逸标识,是否需要逃逸到堆上
if n.Esc == EscNone {
// ...略...
// 不需要逃逸
// 直接栈上分配内存
t = types.NewArray(t.Elem(), i) // [r]T
// ...略...
} else {
// 需要内存逃逸到堆上
// ...略...
// 默认使用makeslice64函数从堆上分配内存
fnname := 'makeslice64'
argtype := types.Types[TINT64]
// ...略...
if (len.Type.IsKind(TIDEAL) || maxintval[len.Type.Etype].Cmp(maxintval[TUINT]) <= 0) &&
(cap.Type.IsKind(TIDEAL) || maxintval[cap.Type.Etype].Cmp(maxintval[TUINT]) <= 0) {
// 校验通过,则
// 使用makeslice函数从堆上分配内存
fnname = 'makeslice'
argtype = types.Types[TINT]
}
// ...略...
// 调用上面指定的runtime函数
m.Left = mkcall1(fn, types.Types[TUNSAFEPTR], init, typename(t.Elem()), conv(len, argtype), conv(cap, argtype))
// ...略...
}
最终分配堆内存的地方都会依赖函数mallocgc
,我们通过阅读mallocgc
的代码就可以看到堆内存的分配过程。
堆内存的分配按对象的大小分,主要分为三大类:
微对象 0 < Micro Object < 16B
小对象 16B =< Small Object <= 32KB
大对象 32KB < Large Object
「微对象」和「小对象」通常通过逻辑处理器结构P
的线程缓存mcache
分配,「大对象」直接从堆上mheap
中分配,如下图所示:
线程缓存mcache
的tiny
结构主要负责分配「微对象」
线程缓存mcache
的alloc
结构主要负责分配「小对象」
微对象 0 < Micro Object < 16B
1. 线程缓存mcache
的tiny
内存充足,则直接分配「微对象」所需内存,图示如下:
2. 线程缓存mcache
的tiny
内存不足,先去线程缓存mcache
的alloc
申请16B给tiny
,再分配「微对象」所需内存,简易图示如下:
申请16B详细过程图示如下:
小对象 16B =< Small Object <= 32KB
1. 线程缓存mcache
的alloc
充足,则直接分配「小对象」所需内存,简易图示如下:
详细分配过程图示如下:
2. 线程缓存mcache
的alloc
不足,则去中央缓存mcentral
获取一个mspan
,再分配「小对象」所需内存,图示如下:
3. 线程缓存mcache
的alloc
不足,且中央缓存mcentral
不足,则去逻辑处理器结构的pagecache
分配,如果pagecache
直接去堆上mheap
获取一个mspan
,再分配「小对象」所需内存,图示如下:
大对象 32KB < Large Object
1. 逻辑处理器结构的pagecache
充足,则直接分配「大对象」所需内存,图示如下:
2. 逻辑处理器结构的pagecache
不足,则直接去堆上mheap
分配「大对象」所需内存,图示如下:
Go语言源代码中「栈内存」和「堆内存」的分配都是虚拟内存,最终CPU在执行指令过程中通过内部的MMU把虚拟内存转化为物理内存。
Go语言编译期间会进行逃逸分析,判断并标记变量是否需要分配到堆上,比如创建Map
、Slice
时。
栈内存分配
小于32KB的栈内存
来源优先级1:线程缓存mcache
来源优先级2:全局缓存stackpool
来源优先级3:逻辑处理器结构p.pagecache
来源优先级4:堆mheap
大于等于32KB的栈内存
来源优先级1:全局缓存stackLarge
来源优先级2:逻辑处理器结构p.pagecache
来源优先级3:堆mheap
堆内存分配
微对象 0 < Micro Object < 16B
来源优先级1:线程缓存mcache.tiny
来源优先级2:线程缓存mcache.alloc
小对象 16B =< Small Object <= 32KB
来源优先级1:线程缓存mcache.alloc
来源优先级2:中央缓存mcentral
来源优先级3:逻辑处理器结构p.pagecache
来源优先级4:堆mheap
大对象 32KB < Large Object
来源优先级1:逻辑处理器结构p.pagecache
来源优先级2:堆mheap
「栈内存」也来源于堆mheap
|