Go语言内存分配源码分析学习笔记

大家好，我是V 哥。GO GO GO，今天来说一说Go语言内存分配问题，Go语言内存分配的源码主要集中在runtime包中，它实现了Go语言的内存管理，包括初始化、分配、回收和释放等。下面来对这些过程详细分析一下，先赞后看，绝不摆烂：

1. 内存管理初始化

源码位置: runtime/malloc.go

关键点：

mheap初始化:
- mheap是整个Go运行时的核心内存分配结构，用于管理大块内存。
- 初始化时，Go会从操作系统中获取一大块内存作为堆空间，通过sysAlloc分配给mheap。

  func mallocinit() {mheap_.init() // 初始化全局mheap_}

mcache初始化:
- 每个P（逻辑处理器）有一个mcache，用来缓存小块内存分配，减少锁竞争。
- mcache由mheap分配，存储小块内存（≤32KB）。

  func allocmcache() *mcache {c := new(mcache)c.refill() // 预填充小内存块return c}

2. 内存分配

Go的内存分配分为以下几种场景：

2.1 小对象分配（≤32KB）

使用mcache中的内存。
mcache按大小类（class）分配，这些类通过sizeclasses数组定义。
分配时，调用mcache.alloc，如果mcache中没有可用的内存块，会从mheap中拉取。

  func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {if size <= maxSmallSize {// 小对象分配c := getmcache() // 获取当前P的mcaches := c.alloc(size, needzero)return s}}

2.2 大对象分配（>32KB）

直接从mheap中分配大块内存。
使用span（连续内存块）管理这些大块内存。

  func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {if size > maxSmallSize {// 大对象分配s := mheap_.allocSpan(size)return s}}

3. 垃圾回收（GC）

源码位置: runtime/mgc.go

Go的垃圾回收器使用三色标记清除算法，主要分以下几个阶段：

标记阶段:
- 从根对象（全局变量、栈变量、寄存器变量）开始，标记所有可达对象。
清除阶段:
- 将未标记的对象回收，释放到mcache或mheap。

   func gcSweep() {// 遍历所有span，清理未使用的对象for _, s := range mheap_.spans {s.sweep()}}

4. 内存释放

源码位置: runtime/malloc.go

Go会主动将不再使用的大块内存返还给操作系统，调用sysUnused或sysFree实现。

关键点：

小对象:
- 释放到mcache。
- 如果mcache满了，释放到mheap。
大对象:
- 直接释放到mheap。
- 如果mheap中内存长时间未使用，释放给操作系统。

5. 内存分配中的优化机制

5.1 线程本地缓存（mcache）

减少全局锁竞争。
小对象分配从mcache中直接获取。

5.2 内存对齐

Go保证分配的内存地址按对象大小对齐（如8字节、16字节等），以提高访问效率。

5.3 分配池（Free List）

回收的内存会进入Free List，供后续快速分配。

5.4 GC触发条件

当堆的增长超过特定比例（默认100%）时触发GC。

Go的内存分配机制结合了现代内存分配的多种优化技术，能够高效地处理并发场景。关键点在于：

小对象通过mcache优化分配速度。
大对象通过mheap管理，提高内存利用率。
垃圾回收器负责自动清理无用内存，保证程序健壮性。
同时，内存释放机制及时将多余内存返还给操作系统，避免浪费。

6. mcache 和 mheap

深入分析 Go 内存管理中核心模块 mcache 和 mheap 的代码实现，可以更好地理解它们的协同工作方式。以下是详细的源码分析：

1. mcache 模块

1.1 mcache 数据结构

mcache 是每个 P (逻辑处理器) 的本地内存缓存，目的是减少对全局堆的锁争用。
它的源码定义在 runtime/mcache.go。

type mcache struct {alloc [numSpanClasses]*mspan // 每个 size class 分配一个 spantiny        uintptr          // 小对象分配缓存tinyoffset  uintptr          // tiny 的当前偏移量local_nlookup uintptr        // 本地分配次数...
}

字段解释:

alloc:
- 存储分配的 spans，按 size class 分类。
- 每个类的 span 会被重用以分配同类大小的对象。
tiny 和 tinyoffset:
- 用于小对象分配（如 mallocgc）。
local_nlookup:
- 用于统计本地内存分配的次数。

1.2 mcache 的主要方法

1.2.1 分配内存 (`mcache.alloc`)

当分配小对象时，调用 alloc 方法从 mcache 中获取内存：

func (c *mcache) alloc(size uintptr, needzero bool) unsafe.Pointer {sc := sizeToClass(size) // 根据 size 找到对应的 size classs := c.alloc[sc]if s == nil || s.freeindex == s.nelems { // 当前缓存中没有可用的 span，从 mheap 中获取s = mheap_.allocSpan(sc)if s == nil {throw("out of memory")}c.alloc[sc] = s}...return obj
}

工作流程:

根据 size 计算 size class。
查找对应的 span:
- 如果 span 有空闲块，从 freeindex 取一个。
- 如果 span 已满，从 mheap 中分配新的 span。
返回分配的对象地址。

1.2.2 释放内存 (`mcache.releaseAll`)

当 GC 发生时，mcache 会将所有未使用的 spans 返还给 mheap。

func (c *mcache) releaseAll() {for i := range c.alloc {s := c.alloc[i]if s != nil {mheap_.freeSpan(s) // 释放到 mheapc.alloc[i] = nil}}
}

2. mheap 模块

2.1 mheap 数据结构

mheap 是全局的堆管理器，负责分配和回收大块内存（span），以及为 mcache 提供支持。它的源码定义在 runtime/mheap.go。

type mheap struct {spans []*mspan        // 全局管理的 spansfreelist [numSpanClasses]*mspan // 每个 size class 的空闲列表arenas [maxArenas]*heapArena // 内存分配的区域lock mutex           // 全局锁...
}

字段解释:

spans:
- 按页索引管理的所有 spans。
freelist:
- 每个 size class 的空闲 span 链表。
arenas:
- 堆内存分配的底层区域，映射到操作系统的物理内存。
lock:
- 对全局堆操作加锁，避免并发问题。

2.2 mheap 的主要方法

2.2.1 分配 span (`mheap.allocSpan`)

当 mcache 需要新的 span 时，会调用 mheap.allocSpan：

func (h *mheap) allocSpan(sc spanClass) *mspan {lock(&h.lock) // 加锁，防止并发冲突s := h.freelist[sc]if s != nil {h.freelist[sc] = s.next // 从 freelist 获取 spanunlock(&h.lock)return s}...unlock(&h.lock)return h.grow(sc) // freelist 没有时，从 arenas 扩展
}

工作流程:

从 freelist 中取出一个空闲的 span。
如果 freelist 为空，调用 grow 方法，从 arenas 分配新的 span。

2.2.2 回收 span (`mheap.freeSpan`)

当 mcache 或垃圾回收器释放内存时，调用 mheap.freeSpan：

func (h *mheap) freeSpan(s *mspan) {lock(&h.lock) // 加锁sc := s.spanclass()s.reset() // 重置 span 状态s.next = h.freelist[sc]h.freelist[sc] = s // 回收到 freelistunlock(&h.lock)
}

工作流程:

通过 spanclass 确定 span 类型。
重置 span 的元数据。
将 span 加入 freelist 链表。

2.3 mheap 内存增长 (`mheap.grow`)

当 freelist 无法满足分配请求时，从底层 arenas 分配新的 span：

func (h *mheap) grow(sc spanClass) *mspan {p := sysAlloc(_PageSize * npage, &memstats.heap_sys) // 从操作系统分配物理内存if p == nil {throw("out of memory")}s := newMSpan() // 创建新的 spans.init(p, npage) ...return s
}