Go三色标记法GC详解

约 1924 字大约 6 分钟

gogctricolor

2025-04-19

概述

Go的垃圾回收器（GC）采用并发三色标记清除算法，配合混合写屏障实现了低延迟的内存回收。从Go 1.5开始引入并发GC，经过多个版本的优化，STW（Stop The World）停顿时间已经降低到亚毫秒级别。本文将深入分析三色标记算法、写屏障机制、GC触发条件以及调优方法。

三色标记算法

三色标记将所有对象分为三种颜色：

标记过程

具体示例：

// 假设对象引用关系：
// Root -> A -> C
// Root -> B -> D
//         B -> E

// 初始状态：所有对象为白色
// Step 1: Root引用A,B → A,B标灰
// Step 2: 扫描A → 发现C → C标灰 → A标黑
// Step 3: 扫描B → 发现D,E → D,E标灰 → B标黑
// Step 4: 扫描C → 无新引用 → C标黑
// Step 5: 扫描D → 无新引用 → D标黑
// Step 6: 扫描E → 无新引用 → E标黑
// 结束：无灰色对象，剩余白色对象被回收

并发标记的问题

GC标记与用户goroutine并发执行时，可能出现对象丢失问题：

对象丢失需要同时满足两个条件：

赋值器插入了黑色→白色的引用
赋值器删除了灰色→白色的引用

写屏障（Write Barrier）

写屏障通过拦截指针写操作来保证标记的正确性。Go经历了几代写屏障的演进：

Dijkstra 插入屏障（Go 1.5-1.7）

// 插入屏障：当A.ref = B时，将B标灰
writePointer(slot, ptr):
    shade(ptr)      // 将新引用的对象标灰
    *slot = ptr

问题：栈上的指针写操作不使用写屏障（性能考虑），因此需要在标记终止阶段STW并重新扫描所有栈。

Yuasa 删除屏障

// 删除屏障：当删除A→B的引用时，将B标灰
writePointer(slot, ptr):
    shade(*slot)    // 将旧引用的对象标灰
    *slot = ptr

混合写屏障（Go 1.8+）

// 混合写屏障：结合插入和删除屏障
writePointer(slot, ptr):
    shade(*slot)    // 旧值标灰
    if current stack is grey:
        shade(ptr)  // 新值标灰
    *slot = ptr

Go 1.8引入的混合写屏障消除了对栈的重新扫描需求：

GC 的完整流程

各阶段详解

// 阶段1: Mark Setup (STW)
// - 开启写屏障
// - 将所有P的mcache刷新到mcentral
// - 扫描所有goroutine的栈（标记根对象）
// STW时间：通常<100μs

// 阶段2: Concurrent Mark
// - GC worker goroutine并发标记
// - 使用25% CPU（GOMAXPROCS/4个worker）
// - 用户goroutine可以被标记辅助（mark assist）征用

// 阶段3: Mark Termination (STW)
// - 关闭写屏障
// - 清理辅助标记的状态
// - 计算下次GC的触发阈值
// STW时间：通常<100μs

// 阶段4: Concurrent Sweep
// - 并发地清除未标记（白色）对象
// - 将内存归还给span freelist
// - 按需进行（分配时触发）

GC 触发条件

// 1. 堆增长触发
// 当堆大小达到上次GC后存活大小 * (1 + GOGC/100)
// 默认GOGC=100，即堆大小翻倍时触发
// 上次GC后存活4MB → 堆达到8MB时触发

// 2. 定时触发
// 超过2分钟未触发GC时，强制触发
// runtime.forcegcperiod = 2 * 60 * 1e9 // 2分钟

// 3. 手动触发
runtime.GC() // 阻塞直到GC完成

// 4. GOMEMLIMIT触发（Go 1.19+）
// 当接近内存限制时，更积极地触发GC

GOGC 与 GOMEMLIMIT

GOGC

// GOGC控制GC的触发频率
// GOGC=100（默认）：堆翻倍时触发
// GOGC=200：堆增长到3倍时触发（更少GC，更多内存）
// GOGC=50：堆增长到1.5倍时触发（更多GC，更少内存）
// GOGC=off：禁用GC

// 计算公式：
// trigger = live * (1 + GOGC/100)
// live=10MB, GOGC=100 → trigger=20MB
// live=10MB, GOGC=200 → trigger=30MB

// 运行时设置
debug.SetGCPercent(200)

GOMEMLIMIT（Go 1.19+）

// 设置软内存限制
// GOMEMLIMIT=1GiB

// 与GOGC配合使用
// GOGC=off + GOMEMLIMIT=1GiB：
// 只在接近1GiB时才触发GC，最大化吞吐量

// GOGC=100 + GOMEMLIMIT=2GiB：
// 正常的GOGC触发 + 内存上限保护

debug.SetMemoryLimit(1 << 30) // 1GiB

GC Trace 分析

# 启用GC trace
GODEBUG=gctrace=1 ./myapp

# 输出示例：
# gc 1 @0.012s 2%: 0.015+3.2+0.009 ms clock, 0.12+0.35/2.8/0.5+0.072 ms cpu, 4->4->2 MB, 4 MB goal, 0 MB stacks, 0 MB globals, 8 P

# 解读：
# gc 1         : 第1次GC
# @0.012s      : 程序启动后0.012秒
# 2%           : GC占用CPU的百分比
# 0.015+3.2+0.009 ms clock : STW1 + 并发标记 + STW2 的wall clock时间
# 0.12+0.35/2.8/0.5+0.072 ms cpu : 各阶段CPU时间
# 4->4->2 MB   : GC开始堆大小 -> GC结束堆大小 -> 存活对象大小
# 4 MB goal    : 下次GC触发目标
# 8 P          : 使用的P数量

GC 优化建议

// 1. 减少堆分配（最重要）
// 使用sync.Pool复用对象
var pool = sync.Pool{
    New: func() interface{} { return new(bytes.Buffer) },
}

// 2. 预分配切片和map
s := make([]int, 0, expectedSize)
m := make(map[string]int, expectedSize)

// 3. 使用值类型代替指针（减少GC扫描）
type Point struct{ X, Y float64 }  // 值类型，内联在父结构中
// 比 *Point 更友好

// 4. 使用 []byte 代替 []*byte
// 连续内存，一次扫描

// 5. 适当调整GOGC
// CPU密集型：GOGC=200-400（减少GC频率）
// 内存敏感型：GOGC=50-100（控制内存使用）

总结

特性	说明
算法	并发三色标记-清除
写屏障	混合写屏障（Go 1.8+）
STW时间	通常<100μs
CPU开销	约25%（标记阶段）
触发条件	堆增长(GOGC) / 定时(2min) / GOMEMLIMIT
调优	GOGC、GOMEMLIMIT、减少分配

Go GC的设计理念是"低延迟优先"，通过并发标记和混合写屏障将STW停顿降到亚毫秒级别。理解GC的工作原理，有助于写出对GC友好的代码，在延迟和吞吐量之间找到最佳平衡点。

贡献者

withesse

更新日志

2026/3/14 13:09

查看所有更新日志

9f6c2-feat: organize wiki content and refresh site setup于 2026/3/14