你有没有遇到过这种场景:服务上线时内存 200MB,跑一夜变成 2GB,重启一下又老老实实回到 200MB。监控面板上 CPU 不高、流量没涨、机器也没换,就是内存像漏水的水管一样一点点往外淌。
运维同事会建议你"加内存"。而我想说:别加,那只是把定时炸弹的引信换成更长的。任何靠加内存掩盖的泄漏,最终都会在某个流量峰值上变成一次生产事故。今天我们不谈玄学,就拿 Go 服务当解剖对象,把三种最常见的内存泄漏现场一个个拆开看。
一、先搞清楚:Go 的"泄漏"和 C++ 有什么不一样
Go 有 GC,这话没错。但 GC 只解决"没人要的垃圾",不解决"你以为没人要、其实还被引用着的东西"。
经典场景:
func getUser(ctx context.Context, id string) (*User, error) {
ch := make(chan *Result, 10)
go func() {
r, _ := heavyQuery(ctx, id)
ch <- &Result{Data: r} // 有人往里写
}()
select {
case r := <-ch:
return r.User, nil
case <-ctx.Done():
return nil, ctx.Err() // 提前返回了
}
}
函数从 ctx.Done() 分支返回,ch 没人读了。但那个 goroutine 还活着,它手里攥着 heavyQuery 的结果、连接、以及从池子里借的 buffer,全都等着往一个永远没人听的 channel 里塞。这不是内存泄漏,这是goroutine 泄漏——而 goroutine 泄漏的栈、闭包捕获的变量、持有的连接池,全是内存泄漏。
goroutine 泄漏是内存泄漏的头号上游。Stack Overflow 上关于 goroutine 泄漏的经典问题比 Go 的 nil pointer 还多,而排查手段却出奇地笨:靠人肉数 goroutine,靠猜代码。
二、工具箱:别猜,去看
Go 自带的 pprof 是全世界最好用的 profiling 工具之一,关键在于你会不会用。改一行代码把 profiler 挂上去:
import (
"net/http"
"net/http/pprof"
)
func init() {
// 只在内部端口开,绝不要暴露到公网
go func() {
http.ListenAndServe("127.0.0.1:6060", nil)
}()
}
然后你需要三个视角:
- heap:谁在占内存。
go tool pprof -http=:8080 http://127.0.0.1:6060/debug/pprof/heap - goroutine:谁在阻塞。
/debug/pprof/goroutine?debug=2直接给你每个 goroutine 的完整栈 - allocs:谁在疯狂分配。抓一段采样,看火焰图
但工具只是让你"看见",真正值钱的是知道"看见之后该想什么"。下面三例,我按真实排查顺序排。
三、现场一:goroutine 卡在 channel 收发上
如果 goroutine 数量只增不减,/debug/pprof/goroutine?debug=2 基本能一眼看出问题。输出长这样:
goroutine 421 [chan receive]:
main.consume(...)
/app/worker.go:88
main.(*Pool).Run(...)
/app/pool.go:42
...
goroutine 418 [chan send]:
main.produce(...)
/app/worker.go:51
...
看到 [chan send] 和 [chan receive] 数量不匹配,就知道是消费者掉线了。修法有三种,按推荐顺序:
// 方案一(首选):让发送端也知道对方没了
select {
case ch <- item:
case <-ctx.Done():
return
}
// 方案二:用 close 广播 + sync.Once 保护
// 生产者 defer close(ch),消费者 range ch
// 方案三(最笨但最稳):context.WithCancel 全链路透传
我在自己的项目里干过的最蠢但最有效的一招:给所有 worker 挂一个独立的 watchdog goroutine,定期检查 goroutine 总数,异常增长就报警。别笑,这是能救命的。
四、现场二:buffer 借了不还,或者还错了池
sync.Pool 是 Go 的性能利器,也是内存黑洞高发区。经典错误是把对象放回池子之前,它的内部还引用着一大块数据:
var bufPool = sync.Pool{
New: func() any { return new(bytes.Buffer) },
}
buf := bufPool.Get().(*bytes.Buffer)
buf.Reset()
defer func() {
// ❌ 危险:buf 里还挂着 10MB 的 payload 引用
bufPool.Put(buf)
}()
// 大对象直接扔掉,别回池
if buf.Cap() > 64*1024 {
buf = new(bytes.Buffer)
}
Reset() 只是把长度归零,底层那块 10MB 的 []byte 还被 buffer 引用着。放回池子 = 把这 10MB 永久寄存在池子里,永远不释放。你以为省了内存,其实给内存装了个水龙头。
另一个更隐蔽的坑:往池子里塞了错误类型。
bufPool.Put("我是个字符串") // 编译能过?No, any 可以
// 之后 Get().(*bytes.Buffer) 直接 panic
所以规矩很简单:
- Pool 里只放同一类型的东西,用泛型包一层做类型安全
- Put 之前确保对象内部引用被清空(
buf.Reset()+ 确认没有 slice 残留) - 大对象直接弃用,小对象才回池——内存紧张时 GC 会自动清空 Pool,这本身是特性不是 bug
五、现场三:切片没截断,你以为的 O(1) 变成了 O(n)
这个不叫"泄漏",但症状一样:内存只涨不降。切片是引用类型,append 会共享底层数组。
// 危险:一个 1MB 的切片,你只用了前 10 个字节
big := make([]byte, 1024*1024)
small := big[:10]
small = append(small, 'x') // small 依然引用着 1MB 的底层数组
// 正确:明确切断引用
small := make([]byte, 0, 16)
small = append(small, big[:10]...)
// 或者需要长生命周期时主动 copy
safe := make([]byte, 10)
copy(safe, big[:10])
更狠的是这种:
// 经典的"append 陷阱"
a := make([]int, 0, 4)
a = append(a, 1, 2, 3, 4) // cap=4, len=4
b := append(a, 5) // 触发扩容,新数组 cap=8
b = append(b, 6, 7, 8) // 又扩容,cap=16
a = a[:cap(a)] // a 还在老数组上
// b 底层那个 cap=16 的数组里只有 5 个元素在用,另外 11 个是纯浪费
解决思路:长生命周期的切片,cap 要显式控制。把 make([]T, 0, n) 当成一种承诺——你承诺了这个切片最多长 n。超出就说明逻辑有 bug,与其默默扩容到 16MB,不如让它 panic。
六、别忘了 RSS 和 Heap 的差额
很多"泄漏"其实是虚惊。Go 的 runtime 拿了大块内存(尤其是 mmap 的大对象)之后,可能不立刻还给操作系统,你从 runtime.ReadMemStats 里看到 Heap 没涨,但 RSS 涨了。
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("HeapAlloc: %d MB\n", m.HeapAlloc/1024/1024)
fmt.Printf("HeapSys: %d MB\n", m.HeapSys/1024/1024)
fmt.Printf("HeapIdle: %d MB\n", m.HeapIdle/1024/1024)
fmt.Printf("HeapReleased: %d MB\n", m.HeapReleased/1024/1024)
关键看 HeapIdle - HeapReleased:这部分是"Go 拿了但没还"的钱。适度调用 debug.FreeOSMemory() 可以还,但别当救命稻草,每调一次都是一次 STW。
真正的判断标准是趋势:HeapAlloc 在稳态负载下是否单调上升。看绝对值没意义,看曲线才有意义。
七、一套能落地的排查流程
- 先确认是真泄漏:HeapAlloc 趋势向上 + 流量稳定 + 业务指标没变,三者同时成立才算
- 看 goroutine 数:
runtime.NumGoroutine()打点画曲线。这个数不回落,八成是 goroutine 泄漏 - 抓 heap profile 两份对比:稳定态抓一份,内存涨 2 倍后再抓一份,用
go tool pprof -base做差集,差集里谁在长,一目了然 - 查 Pool 和全局变量:
sync.Pool、map型全局缓存、闭包捕获的变量,是重灾区 - 审查所有 channel 的 select:每个发送都要有
ctx.Done()分支,每个 consumer 都要能退出 - 加内存上限做兜底:
debug.SetMemoryLimit()让 GC 在接近上限时更激进地工作。这不是修复,是安全带
顺带一句:
debug.SetMemoryLimit()这个 API 是 Go 1.19 才有的,它允许你在容器里告诉 runtime "你只有 2GB 可用"。它不会阻止 OOM,但会让 GC 提前介入,用更多 CPU 换更小的内存峰值。在资源受限的容器环境里,这是最划算的一行代码。
八、写在最后
Go 的内存问题,八成不是 runtime 的锅,也不是"GC 不够勤快"。是并发原语用错了、生命周期没管好、池子被当成了垃圾桶。
我在实践中形成了一个肌肉记忆:任何 channel、任何 goroutine、任何 Pool、任何全局 map,都要能一句话说清楚"它什么时候死"。说不清楚,就是定时炸弹。
工具再好也救不了没想清楚的生命周期设计。pprof 只是让你少猜一点,别指望它替你思考。
如果这篇文章对你有点用,欢迎来 comck.com 逛逛,也欢迎直接拍砖——我写代码的时候也经常被自己的 bug 拍得脸疼。