欢迎来到这篇深入剖析 Go 语言垃圾回收（GC）的文章！垃圾回收是 Go 运行时（runtime）的核心组件，直接影响程序的性能和内存使用效率。无论你是刚开始学习 Go 的新手，还是希望优化高性能应用的资深开发者，理解 GC 的工作原理都至关重要。

本文将详细讲解 Go GC 的完整过程，分析其工作原理，并通过 Go 1.23 的源码带你走进 runtime 的内部实现。我们将采用教学风格，使用类比、代码注释和思考题，确保内容既深入又易懂。准备好一起探索 Go 的内存管理世界了吗？让我们开始！

什么是 Go 的垃圾回收？

在深入 GC 过程之前，我们先来了解它的基本概念和目标。

定义

Go 的垃圾回收是一种自动内存管理机制，负责识别并回收不再使用的内存对象（垃圾），以防止内存泄漏并优化内存使用。Go 使用的是 并发标记-清除（Mark-and-Sweep） 算法，结合 三色标记 和 写屏障，以实现高效的内存回收。

类比：图书馆管理员

你可以把 Go 的 GC 想象成一位“图书馆管理员”：

• 图书馆：程序的堆内存，存放所有动态分配的对象（书籍）。
• 读者：运行中的 Goroutine，可能借阅或归还书籍（创建或删除对象引用）。
• 管理员（GC）：负责整理图书馆，标记哪些书还在使用（存活对象），清理无人借阅的书（垃圾对象）。
• 并发工作：管理员在读者借阅书籍时一起整理，尽量不打断读者的阅读（减少停顿时间）。

目标

• 正确性：确保所有存活对象不被错误回收，防止野指针或程序崩溃。
• 低延迟：通过并发和增量式 GC，减少停顿时间（STW, Stop-The-World）。
• 高吞吐量：优化 GC 的 CPU 和内存开销，提升程序整体性能。

Go 的 GC 是 增量式 和 并发的，与调度器和内存分配器紧密协作，适合高并发场景。

Go GC 的完整过程

Go 的 GC 过程可以分为四个主要阶段：

1. 标记准备（Mark Setup）：初始化 GC，短暂暂停程序（STW）。
2. 并发标记（Concurrent Mark）：与 Goroutine 并发执行，标记存活对象。
3. 标记终止（Mark Termination）：再次暂停程序（STW），完成标记。
4. 并发清除（Concurrent Sweep）：回收未标记对象，恢复正常运行。

以下是每个阶段的详细分析，结合类比和流程描述。

1. 标记准备（Mark Setup）

目标：为标记阶段做准备，初始化 GC 状态和工作队列。

过程：

• 暂停世界（STW）：暂停所有 Goroutine，确保内存状态一致。
• 初始化：设置 GC 阶段（gcphase = _GCmark），启用写屏障，清空标记工作队列。
• 扫描根对象：扫描全局变量、Goroutine 栈和寄存器中的根对象，将它们标记为灰色（待扫描）。
• 恢复运行：重新启动 Goroutine，进入并发标记。

类比：管理员宣布：“图书馆要整理了，大家暂停一下！”他清点借阅记录（根对象），列出需要检查的书（灰色对象），然后让读者继续借阅。

源码剖析： 在 runtime/mgc.go 中，gcStart 函数负责启动 GC：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// runtime/mgc.go
func gcStart(trigger gcTrigger) {
    // 检查是否已在 GC 周期中
    if atomic.Load(&gcphase) != _GCoff {
        return
    }
    // 设置标记阶段
    atomic.Store(&gcphase, _GCmark)
    // 启用写屏障
    writeBarrierEnabled = true
    // 暂停世界
    stopTheWorld("GC mark")
    // 初始化标记工作
    gcController.startCycle()
    // 扫描根对象
    gcMarkRoot()
    // 恢复世界
    startTheWorld()
}

关键点：

• STW：短暂暂停（通常几十微秒），确保初始化安全。
• 根对象：包括全局变量、栈变量和寄存器中的指针，是标记的起点。
• 写屏障：启用以记录并发阶段的引用变化。

2. 并发标记（Concurrent Mark）

目标：标记所有存活对象，与 Goroutine 并发执行。

过程：

• 三色标记算法：使用白、灰、黑三色标记对象：
  • 白色：未扫描，可能为垃圾。
  • 灰色：已知存活，待扫描其引用。
  • 黑色：已扫描，确定存活。
• 工作队列：GC 从灰色对象队列开始，扫描每个对象的字段，将引用的对象标记为灰色，自身标记为黑色。
• 并发执行：GC 工作由专用 Goroutine（forcegchelper）和正常 Goroutine 协作完成。
• 写屏障：记录程序在标记期间的引用变化，确保新引用的对象被标记。

类比：管理员一边整理书架，一边让读者继续借阅。他从借阅记录（灰色对象）开始，检查每本书引用的其他书（字段指针），标记为“在用”（黑色），并记录新借阅（写屏障）。

源码剖析： 标记核心逻辑在 runtime/mgcmark.go 的 markobject 函数中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// runtime/mgcmark.go
func markobject(obj uintptr) {
    // 如果对象已标记为黑色，直接返回
    if marked(obj) {
        return
    }
    // 标记为灰色
    greyobject(obj, nil, nil)
    // 扫描对象字段
    scanobject(obj, gcw)
}

写屏障在 runtime/mbarrier.go 中实现（混合写屏障）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// runtime/mbarrier.go
func writebarrierptr(dst *uintptr, src uintptr) {
    if gcphase == _GCmark {
        // 标记新引用对象（src）
        if src != 0 {
            greyobject(src, nil, nil)
        }
        // 标记旧引用对象（oldsrc）
        oldsrc := *dst
        if oldsrc != 0 {
            greyobject(oldsrc, nil, nil)
        }
    }
}

关键点：

• 三色不变式：保证黑色对象不引用白色对象，写屏障确保新引用对象至少为灰色。
• 并发协作：gcController 动态分配标记任务给 P（处理器），平衡 GC 和业务逻辑的 CPU 使用。
• 性能优化：标记任务分担给多个 Goroutine，减少单点压力。

3. 标记终止（Mark Termination）

目标：完成标记阶段，准备清除。

过程：

• 暂停世界（STW）：再次暂停所有 Goroutine，确保标记完成。
• 最终标记：处理剩余的灰色对象，检查写屏障记录，确保所有存活对象标记为黑色。
• 切换阶段：设置 gcphase = _GCmarktermination，禁用写屏障。
• 恢复运行：启动 Goroutine，进入并发清除。

类比：管理员再次宣布：“整理差不多了，再检查一遍！”他快速核对剩余记录（灰色对象），确保没有遗漏，然后准备清理无人借阅的书。

源码剖析： 标记终止由 gcMarkDone 和 gcMarkTermination 处理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// runtime/mgc.go
func gcMarkTermination() {
    // 暂停世界
    stopTheWorld("GC mark termination")
    // 完成剩余标记
    gcDrain(&gcw, gcDrainNoBlock)
    // 禁用写屏障
    writeBarrierEnabled = false
    // 设置清除阶段
    atomic.Store(&gcphase, _GCsweep)
    // 恢复世界
    startTheWorld()
}

关键点：

• STW：通常比标记准备阶段稍长（几十到几百微秒），因为需要处理剩余工作。
• 最终检查：确保没有遗漏的灰色对象，防止漏标。
• 阶段切换：清除阶段开始，内存回收即将进行。

4. 并发清除（Concurrent Sweep）

目标：回收未标记对象，释放内存。

过程：

• 扫描堆：遍历堆中的内存块，回收白色对象（未标记，视为垃圾）。
• 释放内存：将回收的内存块返回到空闲列表，供后续分配使用。
• 并发执行：清除任务由专用 Goroutine 和内存分配器协作完成。
• 结束 GC：设置 gcphase = _GCoff，等待下一次 GC。

类比：管理员开始清理书架，把无人借阅的书（白色对象）搬走，腾出空间。他一边清理，一边让读者继续借阅新书。

源码剖析： 清除逻辑在 runtime/mgc.go 的 gcSweep 函数中：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// runtime/mgc.go
func gcSweep() {
    // 遍历堆中的 span
    for _, s := range mheap_.allspans {
        if s.state != mSpanInUse {
            continue
        }
        // 检查未标记对象
        for obj := s.base(); obj < s.limit; obj += s.elemsize {
            if !marked(obj) {
                // 回收对象
                freeObject(obj)
            }
        }
    }
    // 设置 GC 阶段为 _GCoff
    atomic.Store(&gcphase, _GCoff)
}

关键点：

• 延迟清除：清除任务是增量式的，内存分配器在需要时触发清除，减少对程序的干扰。
• 空闲列表：回收的内存块加入 mheap 的空闲列表，供 mallocgc 使用。
• 并发优化：清除任务与正常内存分配并行，降低性能开销。

Go GC 的工作原理

现在，我们来分析 Go GC 的核心工作原理，揭示其高效性和并发性的秘密。

1. 三色标记算法

定义：三色标记算法是 Go GC 的核心，基于对象引用图，将对象分为白色、灰色和黑色，通过迭代标记存活对象。

工作流程：

1. 初始时，所有对象为白色。
2. 从根对象（全局变量、栈等）开始，标记为灰色，加入工作队列。
3. 从队列取灰色对象，扫描其引用的对象，标记为灰色，自身标记为黑色。
4. 重复直到队列为空，白色对象为垃圾。

三色不变式：

• 黑色对象不引用白色对象。
• 所有存活对象最终为黑色，垃圾对象保持白色。

源码体现： 三色标记在 markobject 和 scanobject 中实现，灰色队列由 workbuf 管理。

2. 写屏障（混合写屏障）

作用：在并发标记期间，程序可能修改对象引用，写屏障记录这些变化，确保存活对象不被漏标。

实现：Go 1.9 引入混合写屏障，在指针赋值（dst = src）时标记 src（新引用）和 oldsrc（旧引用）为灰色。

源码体现： 如前所述，writebarrierptr 实现了混合写屏障，编译器在指针赋值时插入调用。

3. 停顿时间（STW）

作用：STW 暂停所有 Goroutine，确保内存状态一致，用于标记准备和标记终止。

优化：

• Go 通过并发标记和清除，将 STW 时间控制在微秒到毫秒级别。
• 混合写屏障减少栈扫描需求，进一步缩短 STW。

源码体现： stopTheWorld 和 startTheWorld 控制 STW：

1
2
3
4
5
6
7

// runtime/proc.go
func stopTheWorld(reason string) {
    // 暂停所有 Goroutine
    for _, p := range allp {
        p.status = _Pgcstop
    }
}

4. 调度器协作

作用：GC 与 Go 调度器协作，动态分配标记和清除任务，平衡 GC 和业务逻辑的 CPU 使用。

机制：

• P 分配：gcController 将标记任务分配到处理器（P），通过 gcBgMarkWorker 执行。
• 抢占：调度器在安全点（如函数调用）暂停 Goroutine，确保标记正确性。
• 工作窃取：空闲 P 可以窃取标记任务，提高效率。

源码体现： gcController 的 startCycle 和 endCycle 管理任务分配。

5. 内存分配器协作

作用：内存分配器（mallocgc）触发 GC 并参与清除任务。

机制：

• 在分配内存时，检查堆大小是否触发 GC（shouldTriggerGC）。
• 在清除阶段，延迟回收内存，直到分配器需要空闲块。

源码体现： mallocgc 和 shouldTriggerGC 的逻辑：

1
2
3
4
5
6
7

// runtime/malloc.go
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if shouldTriggerGC() {
        gcStart(gcTrigger{kind: gcTriggerHeap})
    }
    ...
}

优化建议与实践

为了优化 GC 性能，开发者可以采取以下措施：

1. 调整 GOGC：

   • 默认 GOGC=100 适合大多数场景。内存压力大时降低到 50，低延迟场景提高到 200。
   • 使用 runtime/debug.SetGCPercent() 动态调整。

2. 减少内存分配：

   • 复用对象，使用 sync.Pool 缓存。
   • 避免频繁分配大对象，减少堆增长。

3. 监控 GC 性能：

   • 使用 runtime.ReadMemStats() 收集统计信息。
   • 借助 pprof 和 trace 分析 GC 开销和堆分配模式。

4. 理解业务场景：

   • 高吞吐量服务：优化内存分配，减少 GC 频率。
   • 低延迟服务：调整 GOGC，关注 STW 时间。

思考题与扩展阅读

思考题

1. 为什么 Go 的 GC 需要两次 STW？能否完全消除 STW？
2. 如果 GOGC 设置为 0，会发生什么？如何影响程序？
3. 如何通过 pprof 识别 GC 性能瓶颈？

扩展阅读

• Go 官方博客：Go GC: Latency and Throughput
• Go 源码：runtime/mgc.go、runtime/mgcmark.go
• 书籍：《The Go Programming Language》中的内存管理章节
• 工具：go tool pprof 和 runtime/trace

总结

通过本文，我们全面剖析了 Go 语言垃圾回收的完整过程，分为 标记准备、并发标记、标记终止 和 并发清除 四个阶段。我们通过源码分析了关键函数（如 gcStart、markobject、gcSweep），揭示了三色标记算法、混合写屏障和调度器协作的实现细节。

Go 的 GC 通过并发和增量式设计，实现了低延迟和高吞吐量的平衡。其与调度器和内存分配器的紧密协作，使其在高并发场景下表现出色。希望这篇文章能帮助你深入理解 Go 的内存管理机制，并在优化程序性能时更有信心！