Golang内存管理——堆分配

拔剑纵狂歌

已于 2024-08-03 14:59:16 修改

阅读量833

点赞数 22

分类专栏： golang基础知识文章标签： golang 数据结构开发语言后端系统架构

于 2024-08-03 14:57:13 首次发布

本文链接：https://blog.csdn.net/wangye135/article/details/140853064

版权

golang基础知识专栏收录该内容

11 篇文章 0 订阅

订阅专栏

go语言的内存自动分配和回收的，因此内存的使用流程大致为：获取内存——分配内存——回收内存——再分配内存。

其中分配内存分为两方面，堆内存分配和栈内存分配，堆内存和栈内存是两种不同的分配方式，本篇文章主要是堆内存的分配方式。

1. 自主内存管理

Go语言为了方便内存的自主管理，一开始启动的时候会向操作系统申请一大块连续的内存，后续的内存分配都是基于这一大块内存的。如果程序运行过程中，内存不足了，Go语言会再向操作系统进行内存的申请。

为了高效的进行内存管理，Go语言将申请到的内存划分为三个区域，分别为spans、bitmap、arena。其中arena是堆区，GO语言将其划分为一个个8KB的page页，程序运行过程中的内存都是从arena堆区进行分配的。spans和bitmap是为了对arena堆区的高效管理而设置的。

2. mspan 和 ClassID表

我们程序的运行，从使用的角度看，以对象为基本单位的。比如：函数是一个对象、goroutine是一个对象、slice是一个对象。因此，为了实现从对象到内存页之间的映射，Go语言引入了一个mspan结构体。mspan是内存管理的基本单位，每一个span包含一个或多个连续的页。为了满足小对象的分配，会将span中的一页划分为更小的粒度，而对于大对象比如超过页的大小，则会通过多页实现。每个span用于管理特定的class对象，根据对象的大小，span将一个或多个页拆分成多个块进行管理。

mspan的结构体定义如下：位置 runtime:mheap.go 一些字段已经省略了

type mspan struct {
	next *mspan     // 链表后向指针，用于将span链接起来
	prev *mspan     // 链表前向指针，用于将span链接起来
	startAddr uintptr // 起始地址，即所管理页的地址
	npages    uintptr // 该span中占用的page页数

    //作用于GC,垃圾会有的时候会使用这三个字段
	allocBits  *gcBits //分配位图，每一位代表一个块是否已分配
	gcmarkBits *gcBits
	pinnerBits *gcBits 

	allocCount  uint16        // 该Span中已经分配的对象数量
	spanclass   spanClass     // 该Span的等级，一个特定的span中存储特定的ClassID大小的对象
	elemsize    uintptr       // 块大小，该span中存储特定ClassID的大小
}

Class等级列表如下:
源码位置：runtime:sizeclasses.go

划分如此多的Class等级的目的：

尽可能地减少内存浪费
降低从全局缓存中获取特定SpanClass锁的粒度

// class  bytes/obj  bytes/span  objects  tail waste  max waste  min align
//     1          8        8192     1024           0     87.50%          8
//     2         16        8192      512           0     43.75%         16
//     3         24        8192      341           8     29.24%          8
//     4         32        8192      256           0     21.88%         32
//     5         48        8192      170          32     31.52%         16
//     6         64        8192      128           0     23.44%         64
//     7         80        8192      102          32     19.07%         16
//     8         96        8192       85          32     15.95%         32
//     9        112        8192       73          16     13.56%         16
//    10        128        8192       64           0     11.72%        128
//    11        144        8192       56         128     11.82%         16
//    12        160        8192       51          32      9.73%         32
//    13        176        8192       46          96      9.59%         16
//    14        192        8192       42         128      9.25%         64
//    15        208        8192       39          80      8.12%         16
//    16        224        8192       36         128      8.15%         32
//    17        240        8192       34          32      6.62%         16
//    18        256        8192       32           0      5.86%        256
//    19        288        8192       28         128     12.16%         32
//    20        320        8192       25         192     11.80%         64
//    21        352        8192       23          96      9.88%         32
//    22        384        8192       21         128      9.51%        128
//    23        416        8192       19         288     10.71%         32
//    24        448        8192       18         128      8.37%         64
//    25        480        8192       17          32      6.82%         32
//    26        512        8192       16           0      6.05%        512
//    27        576        8192       14         128     12.33%         64
//    28        640        8192       12         512     15.48%        128
//    29        704        8192       11         448     13.93%         64
//    30        768        8192       10         512     13.94%        256
//    31        896        8192        9         128     15.52%        128
//    32       1024        8192        8           0     12.40%       1024
//    33       1152        8192        7         128     12.41%        128
//    34       1280        8192        6         512     15.55%        256
//    35       1408       16384       11         896     14.00%        128
//    36       1536        8192        5         512     14.00%        512
//    37       1792       16384        9         256     15.57%        256
//    38       2048        8192        4           0     12.45%       2048
//    39       2304       16384        7         256     12.46%        256
//    40       2688        8192        3         128     15.59%        128
//    41       3072       24576        8           0     12.47%       1024
//    42       3200       16384        5         384      6.22%        128
//    43       3456       24576        7         384      8.83%        128
//    44       4096        8192        2           0     15.60%       4096
//    45       4864       24576        5         256     16.65%        256
//    46       5376       16384        3         256     10.92%        256
//    47       6144       24576        4           0     12.48%       2048
//    48       6528       32768        5         128      6.23%        128
//    49       6784       40960        6         256      4.36%        128
//    50       6912       49152        7         768      3.37%        256
//    51       8192        8192        1           0     15.61%       8192
//    52       9472       57344        6         512     14.28%        256
//    53       9728       49152        5         512      3.64%        512
//    54      10240       40960        4           0      4.99%       2048
//    55      10880       32768        3         128      6.24%        128
//    56      12288       24576        2           0     11.45%       4096
//    57      13568       40960        3         256      9.99%        256
//    58      14336       57344        4           0      5.35%       2048
//    59      16384       16384        1           0     12.49%       8192
//    60      18432       73728        4           0     11.11%       2048
//    61      19072       57344        3         128      3.57%        128
//    62      20480       40960        2           0      6.87%       4096
//    63      21760       65536        3         256      6.25%        256
//    64      24576       24576        1           0     11.45%       8192
//    65      27264       81920        3         128     10.00%        128
//    66      28672       57344        2           0      4.91%       4096
//    67      32768       32768        1           0     12.50%       8192

3. mcentral 和 mcache

首先，我们申请内存是以goroutine为单位的（也可以说是线程），以线程为单位去获取对应的span。其次为了方便对span的管理，我们需要引入结构体来管理span。结构体就是mcentral。mcentral是一个全局的缓存，各线程需要内存的时候，从central中获取对应的span。为了避免多线程申请内存的时候，不断进行加锁。Go为每一个线程设置了一个本地缓存，也就是mcache。每一个线程需要内存的时候，优先从本地缓存mcache中获取对应的span,如果本地缓存中不存在对应的span,则会从全局队列mcentral中获取。

mcache和mcentral的结构体定义如下：runtime:mcentral.go 和 runtime:mcache.go

// 给定大小的空闲对象全局缓存,一个全局缓存存储特定ClassID的span
type mcentral struct {
	_         sys.NotInHeap
	spanclass spanClass //存储的特定的classID的span

	partial [2]spanSet // 还有空闲块的span列表
	full    [2]spanSet // 无空闲块的span列表
}



// 每一个线程(在Go中,指的是每一个P)都有一个mcache小对象
// 进行操作的时候，不需要锁，因为它是属于每个线程的
type mcache struct {

	alloc [2*68]*mspan // 本cache中被分配的跨度,索引是span对应的classID

	stackcache [_NumStackOrders]stackfreelist //线程中执行栈的空闲span链表
}

以上源码的部分都经过了省略，字段展示的不全，想要深入了解的朋友，自行浏览。

从以上结构体的定义中，我们可以发现，mcache中有所有ClassID的span链表，而mcentral只管理特定ClassID的span。所以，在mcentral上层，应该还有一个结构体，去管理所有ClassID的mcentral,这个结构体就是mheap。

4. mheap

// 分配堆
type mheap struct {
	lock mutex

	/*allspans存储所有已创建的mspan的切片。每个mspan只出现一次
	通常,allspans被mheap的锁保护，防止并发访问，并释放后台存储。*/
	allspans []*mspan // all spans out there

	// 所有的central列表
	central [2*68]struct {
		mcentral mcentral
		pad      [(cpu.CacheLinePadSize - unsafe.Sizeof(mcentral{})%cpu.CacheLinePadSize) % cpu.CacheLinePadSize]byte
	}
}

从上面的mheap结构体的定义，可以发现，mheap是顶级内存分配，通过管理各种类型的mcentral。实际上，Go语言就是通过mheap来管理arean堆区的所有内存的。

5. 申请size为n的内存，分配步骤如下：

为了提升内存分配的效率，当程序执行时可以从优先mcache,mcentral、mheap这三个地方获取内存。

1、对于小于小于等于32kb的内存，优先在mcache (无锁，效率最高) 获取,如果mcache 中没有空闲则从mcentral中获取（有锁，效率次之），mcentral中没有空闲的span,这时候从mheap 中获取（全局锁，效率最低），如果mheap 中也没有可用的span则向操作系统申请（发生系统调用，效率最差）。

2、对于大于32kb 则去mheap 获取，如果没有空闲span 则从系统申请。