Go 并发编程 - 第65课 - 垃圾回收机制

课程难度：Advanced 所属模块：高级特性标签：GC, Tricolor, STW, Pacer 上一课：内存模型与 happens-before 下一课：逃逸分析

1. 学习目标

完成本课学习后，你将能够：

理解 Go 语言垃圾回收（GC）的核心工作原理，特别是三色标记法和写屏障。
掌握监控和观察 Go GC 行为的常用工具与运行时参数。
了解 GC 的“并发标记清除”策略以及其中短暂的“Stop-The-World”（STW）阶段。
认识 GOGC、GC Pacer 等关键参数，理解它们如何影响程序性能与内存使用。

2. 核心概念

什么是垃圾回收（GC）？

想象你有一个仓库（内存），里面堆放着各种箱子（对象）。有些箱子你经常要用（还在使用），有些箱子早已被遗忘（不再引用）。垃圾回收器就像一个勤劳的清洁工，它的任务就是定期检查并清理掉那些不再被使用的箱子，为你腾出空间。

在 Go 中，这个清洁工非常“智能”和“高效”，它几乎可以和你（主程序）同时工作，这就是 并发垃圾回收。

三色标记法（Tricolor Mark-and-Sweep）

这是 GC 的核心算法。我们把所有对象想象成三种颜色：

白色：潜在垃圾。GC 开始前，所有对象都是白色。GC 结束后，剩下的白色对象将被清除。
灰色：正在扫描。对象本身被标记为存活，但它引用的其他对象还没被完全扫描。
黑色：确定存活。对象本身和它引用的所有直接对象都已被扫描确认。

过程简述：

初始化：所有对象为白色，根对象（如全局变量、栈上变量）标记为灰色。
标记阶段：GC 从灰色集合中取出一个对象，将其变黑，并把它引用的所有白色对象变成灰色，放入灰色集合。不断重复，直到灰色集合为空。
清除阶段：遍历堆，将所有仍为白色的对象内存回收。

并发与 STW（Stop-The-World）

为了让 GC 尽量不影响程序运行，Go 的标记和清除工作大部分是与程序并发执行的。但是，在两个关键点必须暂停程序（STW），以确保 GC 视图的一致性：

标记开始时：需要扫描栈、全局变量等根对象，并打开写屏障。
标记结束时：需要关闭写屏障，进行一些收尾工作。

现代硬件和 Go 优化使得 STW 时间被控制在 毫秒甚至微秒级别。

写屏障（Write Barrier）

在并发标记时，程序可能会修改对象的引用关系，这会破坏三色标记的正确性（比如将一个黑色对象指向一个白色对象）。写屏障就像一个“监控探头”，在指针赋值时通知 GC 这个变化，确保不会漏标存活对象。

GC Pacer 与 GOGC

GOGC：这是一个控制 GC 频率的核心环境变量（默认 100）。它表示“当堆内存增长到上次 GC 后存活对象大小的 GOGC% 时，触发下一次 GC”。设置 GOGC=200 意味着堆内存可以增长到上次 GC 后大小的 3 倍（100% + 200%）才触发 GC，这会减少 GC 频率但增加内存使用。
GC Pacer：Go 1.5 引入的更智能的控制器。它不仅考虑堆增长比例，还会动态调整 GC 工作线程的投入力度，目标是在不超过目标堆大小的前提下完成 GC，力求在吞吐量和延迟间取得平衡。

3. 代码示例

示例 1：监控 GC 行为

package main

import (
	"fmt"
	"runtime"
	"runtime/debug"
	"time"
)

func printGCStats() {
	// 获取当前的 GC 统计信息
	stats := new(runtime.MemStats)
	runtime.ReadMemStats(stats)

	fmt.Printf("GC 执行次数: %d\n", stats.NumGC)
	fmt.Printf("上次 GC 后堆内存使用: %.2f MB\n", float64(stats.HeapAlloc)/1024/1024)
	fmt.Printf("堆内存总量: %.2f MB\n", float64(stats.HeapSys)/1024/1024)
	fmt.Printf("总暂停时间: %v\n", stats.PauseTotalNs)
}

func main() {
	// 设置 GC 目标百分比，值越小，GC 越频繁
	debug.SetGCPercent(50) // 默认是100

	// 分配大量内存，模拟对象创建
	fmt.Println("=== 开始分配内存 ===")
	for i := 0; i < 10; i++ {
		// 分配一个大的切片，触发 GC
		_ = make([]byte, 10*1024*1024) // 10MB
		fmt.Printf("分配 %d 次后：\n", i+1)
		printGCStats()
		time.Sleep(500 * time.Millisecond) // 稍作停顿
	}

	fmt.Println("\n=== 显式触发一次 GC ===")
	runtime.GC() // 通常不建议手动调用，这里仅作演示
	printGCStats()
}

示例 2：观察内存分配与 GC

package main

import (
	"fmt"
	"runtime"
	"time"
)

// 创建一个会逃逸到堆上的对象（例如被闭包捕获）
func createData() *[]int {
	data := make([]int, 1<<20) // 1M 个整数，约 8MB
	return &data // 返回指针，导致 data 逃逸到堆上
}

func main() {
	fmt.Println("程序启动。观察内存增长与 GC。")
	var heapBefore, heapAfter uint64

	for i := 0; i < 5; i++ {
		runtime.ReadMemStats(&runtime.MemStats{})
		heapBefore = runtime.MemStats.HeapAlloc

		// 创建一个大的临时对象并立即丢弃（可回收）
		_ = createData()

		// 等待可能发生的 GC
		time.Sleep(2 * time.Second)

		runtime.ReadMemStats(&runtime.MemStats{})
		heapAfter = runtime.MemStats.HeapAlloc

		fmt.Printf("循环 %d: 堆内存: %.2f MB -> %.2f MB, GC次数: %d\n",
			i+1,
			float64(heapBefore)/1024/1024,
			float64(heapAfter)/1024/1024,
			runtime.MemStats.NumGC)
	}
}

4. 实践练习

练习 1：基础监控

编写一个程序，创建一个循环，每次循环分配一个 1MB 的字符串切片，并在每次循环后打印当前的 GC 次数和堆内存使用量。运行程序并观察随着内存分配，GC 是如何被触发的。 预期输出：你会看到 GC 次数随循环次数增加，堆内存使用量呈现“锯齿状”增长。

练习 2：调整 GC 频率

修改练习 1 的程序，使用 debug.SetGCPercent(200) 来增大 GC 触发阈值。比较调整前后，GC 的触发频率和内存占用峰值有何不同。提示：可以分别运行两次程序，对比输出。

练习 3：性能优化思考

考虑以下代码片段：

for i := 0; i < 1000000; i++ {
    obj := new(MyStruct) // 每次循环都分配一个新对象
    process(obj)
}

请思考并尝试解释：

这段代码可能会对 GC 造成什么压力？
如果 process 函数很耗时，且 obj 在函数内不再传递出去，那么这个对象的生命周期是怎样的？GC 能否在 process 执行期间回收它？为什么？
（进阶）如果 process 很快，但你希望减少内存分配开销，可以考虑什么优化手段？（提示：考虑对象池 sync.Pool）

5. 常见错误

忽略 GC 开销：认为 Go 有 GC 就可以随意分配内存。在高性能场景中，过高的内存分配率是导致 CPU 压力增大和延迟抖动的主要原因。
滥用 runtime.GC()：手动调用 runtime.GC() 几乎总是不必要的，它会强制触发一次完整的 GC，可能导致意外的长时间 STW。GC 的 Pacer 通常比人更“聪明”。
不当使用 sync.Pool：将 sync.Pool 当作一个永久的对象缓存。它设计用于复用临时对象，其生命周期不确定，可能会在任意两次 GC 后被清空。不要存放需要持久保持状态的对象。
忽视逃逸分析：不理解哪些变量会分配到栈上，哪些会逃逸到堆上。栈分配成本极低且无需 GC，而堆分配是 GC 的主要压力来源。可以使用 go build -gcflags="-m" 来分析逃逸情况。
过早优化：在不量化（使用 pprof）的情况下，就凭感觉优化 GC。GC 调优应该是基于分析的、有针对性的行为。

6. 小结

本节课我们深入探讨了 Go 语言的垃圾回收机制：

核心算法：Go 采用三色标记法配合写屏障，实现了高效的并发垃圾回收。
工作模式：GC 是并发运行的，只在标记开始和结束时有两个短暂的 Stop-The-World (STW) 暂停，现代版本的 STW 时间已优化到极致。
控制策略：GOGC 参数和更智能的 GC Pacer 共同控制着 GC 的触发时机和资源投入，以平衡吞吐量与内存占用。
关键认知：理解 GC 的工作原理，是为了更好地编写对 GC 友好的代码——减少不必要的堆内存分配，才是优化 GC 性能的根本。
监控工具：使用 runtime.MemStats、GODEBUG=gctrace=1 环境变量以及 pprof 工具是监控和诊断 GC 问题的利器。

理解 GC 不是为了干预它，而是为了在设计程序和处理内存时做出更明智的决策，从而编写出更高效、更稳定的 Go 应用程序。在下一课中，我们将学习逃逸分析，这正是决定一个变量“住在哪里”（栈还是堆）的关键机制。

垃圾回收机制