欢迎来到这篇深入剖析 Go 语言垃圾回收（GC）具体流程的文章！垃圾回收是 Go 运行时（runtime）的核心机制，负责自动管理内存，确保程序高效运行。理解 GC 的流程不仅能帮助你优化程序性能，还能让你更深入地掌握 Go 的内存管理。

本文将以教学风格，结合 Go 1.23 的源码，详细拆解 GC 的每一个阶段，从标记准备到并发清除。我们将使用类比、代码注释和思考题，确保内容既深入又易懂。无论你是 Go 新手还是希望优化高并发应用的开发者，这篇文章都将为你提供宝贵洞察！准备好探索 Go 的内存世界了吗？让我们开始！

什么是 Go 的垃圾回收？

定义

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

类比：图书馆多人协作整理

想象堆内存是一个巨大的图书馆，对象是书籍，GC 是一个由多位管理员组成的团队：

• 图书馆（堆）：存放所有动态分配的书籍（对象）。
• 读者（Goroutine）：不断借阅和归还书（创建或修改对象引用）。
• 管理员团队（GC）：负责标记哪些书还在使用（存活对象），清理无人借阅的书（垃圾）。
• 并发整理：管理员在读者借阅时一起整理，尽量不打断读者（减少 STW）。
• 记录员（写屏障）：记录读者的借阅变化，确保整理准确。

Go 的 GC 通过并发执行标记和清除，与调度器和内存分配器协作，实现了低延迟和高吞吐量的平衡。

目标

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

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，进入并发标记。

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

源码剖析： gcStart 函数在 runtime/mgc.go 中启动 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")
    // 初始化 GC 控制器
    gcController.startCycle()
    // 扫描根对象
    gcMarkRoot()
    // 恢复世界
    startTheWorld()
}

gcMarkRoot 扫描根对象：

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

// runtime/mgc.go
func gcMarkRoot() {
    // 扫描全局变量
    for _, g := range globals {
        if g != nil {
            greyobject(uintptr(unsafe.Pointer(g)), nil, nil)
        }
    }
    // 扫描 Goroutine 栈
    forEachGoroutine(func(gp *g) {
        scanstack(gp, gcw)
    })
}

关键点：

• STW 时间：通常几十微秒，取决于根对象数量。
• 灰色对象：根对象标记为灰色，存入 workbuf 队列。
• 写屏障：启用以记录并发标记期间的引用变化。

教学提示： 标记准备就像管理员快速整理“借阅记录本”，确保起点准确，然后让读者继续工作。

2. 并发标记（Concurrent Mark）

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

流程：

• 三色标记算法：
  • 白色：未扫描，可能为垃圾。
  • 灰色：已知存活，待扫描其引用。
  • 黑色：已扫描，确定存活。
• 工作队列：从灰色队列取对象，扫描其字段中的指针，将引用的对象标记为灰色，自身标记为黑色。
• 并发协作：GC 工作者（gcBgMarkWorker）和 Goroutine 协作，动态分配标记任务。
• 写屏障：记录 Goroutine 的引用变化，确保三色不变式（黑色对象不引用白色对象）。

类比： 管理员团队分散到书架，从待整理清单（灰色队列）取书，检查每本书引用的其他书（字段指针），标记为“在用”（黑色）。记录员（写屏障）随时记录读者借阅的新书，确保不漏掉。

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

 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)
}

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

// runtime/mgcmark.go
func scanobject(obj uintptr, gcw *gcWork) {
    // 获取对象类型
    t := objType(obj)
    // 遍历字段
    for _, ptr := range t.pointers() {
        if ptr != 0 {
            // 标记引用的对象为灰色
            greyobject(ptr, nil, nil)
        }
    }
    // 标记为黑色
    setMarked(obj)
}

写屏障（混合写屏障）：

 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），支持工作窃取。
• 性能：标记任务分散执行，减少对 Goroutine 的干扰。

教学提示： 并发标记就像管理员和读者同时工作，管理员整理书架（标记），记录员确保借阅记录（写屏障）不丢失。

3. 标记终止（Mark Termination）

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

流程：

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

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

源码剖析： 标记终止由 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 时间：通常几十到几百微秒，取决于剩余灰色对象。
• 最终检查：gcDrain 确保灰色队列为空。
• 阶段切换：清除阶段开始，内存回收即将进行。

教学提示： 标记终止就像管理员最后核对“待办清单”，确保所有在用书籍都标记好，然后准备清理。

4. 并发清除（Concurrent Sweep）

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

流程：

• 扫描堆：遍历堆中的内存块（mspan），回收白色对象（未标记，视为垃圾）。
• 释放内存：将回收的内存块返回到空闲列表（mheap.free）。
• 并发执行：清除任务由专用 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)
}

关键点：

• 延迟清除：清除任务按需执行，与内存分配（mallocgc）协作，减少开销。
• 空闲列表：回收的内存加入 mheap.free，供后续分配。
• 并发优化：清除任务分散执行，不影响 Goroutine。

教学提示： 并发清除就像管理员在读者借阅时悄悄清理空书架，腾出空间但不打扰读者。

GC 流程的协作机制

Go 的 GC 流程依赖以下机制的协作，确保高效和正确性：

1. 三色标记算法

• 作用：通过白、灰、黑三色，迭代标记存活对象。
• 实现：markobject 和 scanobject 管理对象颜色，workbuf 存储灰色队列。
• 源码体现：灰色队列动态调整，支持多 P 并发标记。

2. 混合写屏障

• 作用：记录并发标记期间的引用变化，维护三色不变式。
• 实现：writebarrierptr 标记 src 和 oldsrc，汇编优化减少开销。
• 源码体现：编译器注入写屏障调用，调度器确保安全执行。

3. 调度器协作

• 作用：动态分配 GC 任务，平衡 GC 和业务逻辑的 CPU 使用。
• 实现：gcController 分配标记任务，调度器在安全点抢占 Goroutine。
• 源码体现：gcBgMarkWorker 和 schedule 协作运行。

4. 内存分配器协作

• 作用：触发 GC 并参与清除任务。
• 实现：mallocgc 检查堆大小（shouldTriggerGC），延迟清除优化性能。
• 源码体现：mheap 管理空闲列表，gcSweep 按需回收。

源码示例（触发 GC）：

1
2
3
4
5
6
7
8
9

// runtime/malloc.go
func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
    if shouldTriggerGC() {
        gcStart(gcTrigger{kind: gcTriggerHeap})
    }
    // 分配内存
    p := allocate(size, typ)
    return p
}

实际案例分析

案例：高并发服务 GC 频率过高

问题：一个高并发 API 服务发现 GC 每秒触发多次，导致 CPU 占用高，响应延迟增加。

分析：

1. GC 日志（GODEBUG=gctrace=1）：显示 GC 每 100ms 触发，堆大小快速增长。
2. pprof：发现大量临时切片分配在 json.Marshal 中。
3. Trace：确认标记阶段占用 CPU，STW 时间约为 0.2ms。

解决方案：

• 使用 sync.Pool 缓存切片，减少内存分配。
• 调高 GOGC 到 200，降低 GC 频率。
• 优化 JSON 序列化，减少临时对象。

结果：GC 频率降至每秒 0.3 次，CPU 占用降低 25%，延迟改善 15%。

教学提示： 这个案例就像管理员发现读者频繁借新书（分配），导致整理过于频繁。通过减少借书（优化分配）和调整整理频率（GOGC），图书馆更高效。

优化建议

1. 减少内存分配：
   • 使用 sync.Pool 复用对象，减少写屏障调用。
   • 优化切片、字符串和 map 操作，避免不必要分配。
2. 调整 GOGC：
   • 高吞吐量场景：调高到 200，减少 GC 频率。
   • 内存受限场景：调低到 50，增加回收频率。
3. 监控 GC 性能：
   • 使用 runtime.ReadMemStats() 检查堆大小和 GC 次数。
   • 启用 GODEBUG=gctrace=1 观察暂停时间。
   • 使用 runtime/trace 分析 GC 时间分布。
4. 调度优化：
   • 控制 Goroutine 数量，避免调度器竞争。
   • 测试 GOMAXPROCS 对 GC 性能的影响。

思考题与扩展阅读

思考题

1. 如果标记终止阶段的 STW 时间过长，可能是什么原因？如何优化？
2. 并发清除的延迟回收机制如何影响内存分配性能？
3. 在什么场景下，调高 GOGC 可能导致内存浪费？

扩展阅读

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

总结

通过本文，我们全面拆解了 Go 语言 GC 的具体流程，分为：

• 标记准备：初始化 GC，扫描根对象，短暂 STW。
• 并发标记：使用三色标记和写屏障，与 Goroutine 并发执行。
• 标记终止：完成标记，切换阶段，再次 STW。
• 并发清除：回收白色对象，按需释放内存。

结合 Go 1.23 源码，我们分析了 gcStart、markobject、gcSweep 等关键函数，揭示了三色标记、写屏障和调度器协作的实现细节。通过案例和优化建议，你可以更自信地监控和优化 GC 性能。