Golang内存管理详解

基础

存储金字塔

CPU寄存器
CPU Cache：三级Cache分别是L1、L2、L3，L1最快，L3最慢
内存
硬盘等辅助存储设备
鼠标等外接设备

从上至下的访问速度越来越慢，访问时间越来越长。

虚拟内存

访问内存，实际访问的是虚拟内存，虚拟内存通过页表查看，当前要访问的虚拟内存地址，是否已经加载到了物理内存。如果已经在物理内存，则取物理内存数据，如果没有对应的物理内存，则从磁盘加载数据到物理内存，并把物理内存地址和虚拟内存地址更新到页表。

物理内存就是磁盘存储缓存层，在没有虚拟内存的时代，物理内存对所有进程是共享的，多进程同时访问同一个物理内存会存在并发问题。而引入虚拟内存后，每个进程都有各自的虚拟内存，内存的并发访问问题的粒度从多进程级别，可以降低到多线程级别。

栈和堆

代码中使用的内存地址都是虚拟内存地址，而不是实际的物理内存地址。栈和堆只是虚拟内存上2块不同功能的内存区域：

栈在高地址，从高地址向低地址增长
堆在低地址，从低地址向高地址增长

栈和堆相比有这么几个好处：

栈的内存管理简单，分配比堆上快。
栈的内存不需要回收，而堆需要进行回收，无论是主动free，还是被动的垃圾回收，这都需要花费额外的CPU。
栈上的内存有更好的局部性，堆上内存访问就不那么友好了，CPU访问的2块数据可能在不同的页上，CPU访问数据的时间可能就上去了。

内存分区

Golang内存分区：代码区、数据区、堆区、栈区

// 低地址  ——----------------------------------------------------------------》 高地址
// 代码区   |   数据区（初始化数据区，未初始化数据区，常量区）  |   堆区  |  栈区（函数信息，内部变量）
// 函数地址（0x7c7620）：代码区。是一个低地址位置，计算机指令
// 全局变量（0xd03250) ：初始化数据区，如果初始化了：初始化数据；未初始化：未初始化数据
// 局部变量（0xc0000120b0）：栈区，高地址
// 堆区：一个很大的空间，在使用时，开辟内存空间，结束时，释放内存空间。
// 栈区：用来存储程序执行过程中函数内部定义的信息和局部变量值。

最内层函数后进先出，最内层函数先执行后，释放内存，向上层传递结果。函数return返回值将函数执行的结果保存下来，返回给调用者。

变量

局部变量

在C语言中写在{}中或者函数中或者函数的形参, 就是局部变量
Go语言中的局部变量和C语言一样

全局变量

在C语言中写在函数外面的就是全局变量
Go语言中的全局变量和C语言一样

局部变量和全局变量的作用域

在C语言中局部变量的作用域是从定义的那一行开始, 直到遇到 } 结束或者遇到return为止
Go语言中局部变量的作用域和C语言一样
在C语言中全局变量的作用域是从定义的那一行开始, 直到文件末尾为止
Go语言中的全局变量, 只要定义了, 在定义之前和定义之后都可以使用

局部变量和全局变量的生命周期

在C语言中局部变量, 只有执行了才会分配存储空间, 只要离开作用域就会自动释放, C语言的局部变量存储在栈区
Go语言局部变量的生命周期和C语言一样
在C语言中全局变量, 只要程序一启动就会分配存储空间, 只有程序关闭才会释放存储空间, C语言的全局变量存储在静态区(数据区)
Go语言全局变量的生命周期和C语言一样

局部变量和全局变量的注意点

在C语言中相同的作用域内, 不能出现同名的局部变量
Go语言和C语言一样, 相同干的作用域内, 不能出现同名的局部变量

package main
import "fmt"
func main() {
    var num int; // 局部变量
    //var num int; // 报错,不能出现同名局部变量
}

在C语言中相同的作用域内, 可以出现同名的全局变量
在Go语言中相同的作用域内, 不能出现同名的全局变量
例：

package main
import "fmt"
var value int // 全局变量
//var value int // 报错,不能出现同名全局变量
func main() {
}

特殊点

在C语言中局部变量没有初始化存储的是垃圾数据, 在Go语言中局部变量没有初始化, 会默认初始化为0
在C语言中全局变量没有初始化存储的是0, Go语言和C语言一样
在Go语言中, 如果定义了一个局部变量, 但是没有使用这个局部变量, 编译会报错
在Go语言中, 如果定义了一个全局变量, 但是没有使用这个全局变量, 编译不会报错

注意点

相同的作用域内, 无论是全局变量还是局部变量, 都不能出现同名的变量
变量离开作用域就不能使用
局部变量如果没有使用, 编译会报错, 全局变量如果没有使用, 编译不会报错
:=只能用于局部变量, 不能用于全局变量
:=如果用于同时定义多个变量, 会有退化赋值现象，如果通过:=定义多个变量, 但是多个变量中有的变量已经在前面定义过了, 那么只会对没有定义过的变量执行:=, 而定义过的变量只执行=操作

堆内存管理

内存分配 Malloc : memory allocator

当我们说内存管理的时候，主要是指堆内存的管理，因为栈的内存管理不需要程序去操心。

当发现内存申请的时候，堆内存就会从未分配内存分割出一个小内存块(block)，然后用链表把所有内存块连接起来。需要一些信息描述每个内存块的基本信息，比如大小(size)、是否使用中(used)和下一个内存块的地址(next)，内存块实际数据存储在data中。

一个内存块包含了3类信息：元数据、用户数据和对齐字段。

释放内存实质是把使用的内存块从链表中取出来，然后标记为未使用，当分配内存块的时候，可以从未使用内存块中优先查找大小相近的内存块，如果找不到，再从未分配的内存中分配内存。

TCMalloc （Thread Cache Malloc）

TCMalloc是 Google 开发的内存分配器，Golang 使用了类似的算法进行内存分配。

同一进程下的所有线程共享相同的内存空间，它们申请内存时需要加锁，如果不加锁就存在同一块内存被2个线程同时访问的问题。

TCMalloc的做法是什么呢？为每个线程预分配一块缓存，线程申请小内存时，可以从缓存分配内存，这样有2个好处：

为线程预分配缓存需要进行1次系统调用，后续线程申请小内存时直接从缓存分配，都是在用户态执行的，没有了系统调用，缩短了内存总体的分配和释放时间，这是快速分配内存的第二个层次。
多个线程同时申请小内存时，从各自的缓存分配，访问的是不同的地址空间，从而无需加锁，把内存并发访问的粒度进一步降低了，这是快速分配内存的第三个层次。

基本原理

Span

一组连续的Page被称为Span，比如可以有2个页大小的Span，也可以有16页大小的Span
Span比Page高一个层级，是为了方便管理一定大小的内存区域
Span是TCMalloc内存管理的基本单位

ThreadCache

ThreadCache是每个线程各自的Cache
一个Cache包含多个空闲内存块链表，每个链表连接的都是内存块，同一个链表上内存块的大小是相同的
这样可以根据申请的内存大小，快速从合适的链表选择空闲内存块。由于每个线程有自己的ThreadCache
ThreadCache访问是无锁的

CentralCache

CentralCache是所有线程共享的缓存，也是保存的空闲内存块链表，链表的数量与ThreadCache中链表数量相同
当ThreadCache的内存块不足时，可以从CentralCache获取内存块；当ThreadCache内存块过多时，可以放回CentralCache。
由于CentralCache是共享的，所以它的访问是要加锁的。

PageHeap

PageHeap是对堆内存的抽象，PageHeap存的也是若干链表，链表保存的是Span。
当CentralCache的内存不足时，会从PageHeap获取空闲的内存Span，然后把1个Span拆成若干内存块，添加到对应大小的链表中并分配内存；
当CentralCache的内存过多时，会把空闲的内存块放回PageHeap中。
可以有是1页Page的Span链表，2页Page的Span链表等，最后是large span set，这个是用来保存中大对象的。
PageHeap也是要加锁的。

TCMalloc对象大小的定义：

小对象大小：0~256KB
中对象大小：257KB~1MB
大对象大小：>1MB

对象分配流程：

小对象的分配流程：
- ThreadCache -> CentralCache -> HeapPage
- 大部分时候，ThreadCache缓存都是足够的，不需要去访问CentralCache和HeapPage，无系统调用配合无锁分配，分配效率是非常高的。
中对象分配流程：直接在PageHeap中选择适当的大小即可，128 Page的Span所保存的最大内存就是1MB。
大对象分配流程：从large span set选择合适数量的页面组成span，用来存储数据。

Go内存结构

Go在程序启动的时候，会先向操作系统申请一块内存（注意这时还只是一段虚拟的地址空间，并不会真正地分配内存），切成小块后自己进行管理。

申请到的内存块被分配了三个区域，在X64上分别是512MB，16GB，512GB大小。

arena

arena就是我们所谓的堆区，Go动态分配的内存都是在这个区域，它把内存分割成8KB大小的页，一些页组合起来称为mspan

bitmap

bitmap区域标识arena区域哪些地址保存了对象，并且用4bit标志位表示对象是否包含指针、GC标记信息。

bitmap中一个byte大小的内存对应arena区域中4个指针大小（指针大小为 8B ）的内存，所以bitmap区域的大小是512GB/(4*8B)=16GB。

spans

spans区域存放mspan的指针（也就是一些arena分割的页组合起来的内存管理基本单元，后文会再讲），每个指针对应一页，所以spans区域的大小就是512GB/8KB*8B=512MB。除以8KB是计算arena区域的页数，而最后乘以8是计算spans区域所有指针的大小。创建mspan的时候，按页填充对应的spans区域，在回收object时，根据地址很容易就能找到它所属的mspan。

Go内存管理

GO比TCMalloc还多了2件东西：逃逸分析和垃圾回收

基本概念

page

与TCMalloc中的Page相同

span

与TCMalloc中的Span相同，代码中为mspan
Span是内存管理的基本单位

mcache

mcache 是提供给 P 的本地内存池。

mcache与TCMalloc中的ThreadCache类似，mcache保存的是各种大小的Span，并按Span class分类，小对象直接从mcache分配内存，它起到了缓存的作用，并且可以无锁访问。

不同点：

TCMalloc中是每个线程1个ThreadCache，Go中是每个P拥有1个mcache
因为在Go程序中，当前最多有GOMAXPROCS个线程在运行，所以最多需要GOMAXPROCS个mcache就可以保证各线程对mcache的无锁访问，线程的运行又是与P绑定的，把mcache交给P刚刚好。

mcentral

mcentral与TCMalloc中的CentralCache类似，是所有线程共享的缓存，需要加锁访问。它按Span级别对Span分类，然后串联成链表，当mcache的某个级别Span的内存被分配光时，它会向mcentral申请1个当前级别的Span。

不同点：

CentralCache是每个级别的Span有1个链表
mcentral是每个级别的Span有2个链表

mheap

代表Go程序持有的所有堆空间，Go程序使用一个mheap的全局对象_mheap来管理堆内存。

mheap与TCMalloc中的PageHeap类似，它是堆内存的抽象，把从OS申请出的内存页组织成Span，并保存起来。
当mcentral的Span不够用时会向mheap申请内存，而mheap的Span不够用时会向OS申请内存。
mheap向OS的内存申请是按页来的，然后把申请来的内存页生成Span组织起来，同样也是需要加锁访问的。

不同点：

mheap把Span组织成了树结构，而不是链表，并且还是2棵树
mheap把Span分配到heapArena进行管理，它包含地址映射和span是否包含指针等位图，这样做的主要原因是为了更高效的利用内存：分配、回收和再利用。

GO内存大小转化

object size：代码里简称size，指申请内存的对象大小。
size class：代码里简称class，它是size的级别，相当于把size归类到一定大小的区间段
- size[1,8]属于size class 1
- size(8,16]属于size class 2
- size(16,32]属于size class 3
- size(32,48]属于size class 4
span class：指span的级别，但span class的大小与span的大小并没有正比关系。span class主要用来和size class做对应，1个size class对应2个span class，2个span class的span大小相同，只是功能不同，1个用来存放包含指针的对象，一个用来存放不包含指针的对象，不包含指针对象的Span就无需GC扫描了。
num of page：代码里简称npage，代表Page的数量，其实就是Span包含的页数，用来分配内存。

class  1      2      3      4      5      6  ···   63      64      65      66

bytes  8      16     32     48     64     80 ···  24576   27264   28672   32768

Go内存分配

内存分配由内存分配器完成。分配器由3种组件构成：mcache, mcentral, mheap。

内存分类

当要分配大于 32K 的对象时，从 mheap 分配。
当要分配的对象小于等于 32K 大于 16B 时，从 P 上的 mcache 分配，如果 mcache 没有内存，则从 mcentral 获取，如果 mcentral 也没有，则向 mheap 申请，如果 mheap 也没有，则从操作系统申请内存。
当要分配的对象小于等于 16B 时，从 mcache 上的微型分配器上分配。

大小对象

小对象：小对象是在mcache中分配的
- Tiny对象：大小在1~16Byte之间并且不包含指针的对象
- 其他小对象： 16Byte~32KB
大对象：大于32KB，直接从mheap分配

小对象内存分配

size class数量：_NumSizeClasses=67
span class数量：numSpanClasses = _NumSizeClasses * 2 = 134
也就是mcache最多有134个span

1. 为对象寻找span：

计算对象所需内存大小size
根据size到size class映射，计算出所需的size class
根据size class和对象是否包含指针计算出span class
获取该span class指向的span
举例：24Byte对象属于size class 3，对应的span class为7

2. 从span分配对象空间

Span可以按对象大小切成很多份：以size class 3对应的span为例，span大小是8KB，每个对象实际所占空间为32Byte，这个span就被分成了256块。
随着内存的分配，span中的对象内存块，有些被占用，有些未被占用，当分配内存时，只要快速找到第一个可用的绿色块，并计算出内存地址即可。
当span内的所有内存块都被占用时，没有剩余空间继续分配对象，mcache会向mcentral申请1个span，mcache拿到span后继续分配对象。

3. mcache向mcentral申请span

mcentral和mcache一样，都是0~133这134个span class级别，但每个级别都保存了2个span list，即2个span链表：

nonempty：这个链表里的span，所有span都至少有1个空闲的对象空间。这些span是mcache释放span时加入到该链表的。
empty：这个链表里的span，所有的span都不确定里面是否有空闲的对象空间。当一个span交给mcache的时候，就会加入到该链表

mcache向mcentral申请span时，mcentral会先从nonempty搜索满足条件的span，如果没有找到再从emtpy搜索满足条件的span，然后把找到的span交给mcache。

4. mheap的span管理

mheap里保存了两棵二叉排序树，按span的page数量进行排序：

free：free中保存的span是空闲并且非垃圾回收的span。
scav：scav中保存的是空闲并且已经垃圾回收的span。

如果是垃圾回收导致的span释放，span会被加入到scav，否则加入到free，比如刚从OS申请的的内存也组成的Span。

mheap中还有arenas(动态分配的堆区)，由一组heapArena组成，每一个heapArena都包含了连续的pagesPerArena个span，这个主要是为mheap管理span和垃圾回收服务。arenas本身是一个全局变量，它里面的数据，也都是从OS直接申请来的内存，并不在mheap所管理的那部分内存以内。

5. mcentral向mheap申请span

当mcentral向mcache提供span时，如果empty里也没有符合条件的span，mcentral会向mheap申请span。

此时，mcentral需要向mheap提供需要的内存页数和span class级别，然后它优先从free中搜索可用的span。如果没有找到，会从scav中搜索可用的span。如果还没有找到，它会向OS申请内存，再重新搜索2棵树，必然能找到span。

如果找到的span比需要的span大，则把span进行分割成2个span，其中1个刚好是需求大小，把剩下的span再加入到free中去，然后设置需要的span的基本信息，然后交给mcentral。

6. mheap向OS申请内存

当mheap没有足够的内存时，mheap会向OS申请内存，把申请的内存页保存为span，然后把span插入到free树。此时，mcentral需要向mheap提供需要的内存页数和span class级别，然后它优先从free中搜索可用的span。如果没有找到，会从scav中搜索可用的span。如果还没有找到，它会向OS申请内存，再重新搜索2棵树，必然能找到span。

大对象内存分配

当要分配大于 32K 的对象时，从 mheap 分配。

大对象的分配比小对象省事多了，99%的流程与mcentral向mheap申请内存的相同，所以不重复介绍了。不同的一点在于mheap会记录一点大对象的统计信息，详情见mheap.alloc_m()。

垃圾回收和内存释放

垃圾回收收集不再使用的span，调用mspan.scavenge()把span释放还给OS（并非真释放，只是告诉OS这片内存的信息无用了，如果你需要的话，收回去好了）
然后交给mheap，mheap对span进行span的合并，把合并后的span加入scav树中
等待再分配内存时，由mheap进行内存再分配

栈内存

每个goroutine都有自己的栈，栈的初始大小是2KB，100万的goroutine会占用2G，但goroutine的栈会在2KB不够用时自动扩容，当扩容为4KB的时候，百万goroutine会占用4GB。

应用程序的内存会分成堆区（Heap）和栈区（Stack）两个部分，程序在运行期间可以主动从堆区申请内存空间，这些内存由内存分配器分配并由垃圾收集器负责回收。

栈区的内存由编译器自动进行分配和释放，栈区中存储着函数的参数以及局部变量，它们会随着函数的创建而创建，函数的返回而销毁。

go语言编译器会自动决定把一个变量放在栈还是放在堆，编译器会做逃逸分析(escape analysis)，当发现变量的作用域没有跑出函数范围，就可以在栈上，反之则必须分配在堆。

总结

Go内存分配管理的策略有如下几点：

Go在程序启动时，会向操作系统申请一大块内存，由mheap结构全局管理。
Go内存管理的基本单元是mspan，每种mspan可以分配特定大小的object。
mcache， mcentral， mheap是Go内存管理的三大组件：
- mcache管理线程在本地缓存的mspan（无锁）
- mcentral管理全局的mspan供所有线程使用（有锁）
- mheap管理Go的所有动态分配内存。（有锁）
Tiny对象（0~16B且无指针），一般小对象通过mcache分配内存（16B~32K ）；大对象则直接由mheap分配内存（大于32K）。

Reference

https://zhuanlan.zhihu.com/p/...

https://blog.haohtml.com/arch...

https://zhuanlan.zhihu.com/p/...

https://blog.csdn.net/kevin_t...

Golang内存管理详解

基础

存储金字塔

虚拟内存

栈和堆

内存分区

变量

堆内存管理

TCMalloc （Thread Cache Malloc）

基本原理

page

Span

ThreadCache

CentralCache

PageHeap

TCMalloc对象大小的定义：

对象分配流程：

Go内存结构

arena

bitmap

spans

Go内存管理

基本概念

page

span

mcache

mcentral

mheap

GO内存大小转化

Go内存分配

内存分类

大小对象

小对象内存分配

1. 为对象寻找span：

2. 从span分配对象空间

3. mcache向mcentral申请span

4. mheap的span管理

5. mcentral向mheap申请span

6. mheap向OS申请内存

大对象内存分配

垃圾回收和内存释放

栈内存

总结

Reference

你可能感兴趣的:(golang)