你的 Go 服务正在偷偷吃掉内存:三种泄漏现场、四个工具、一个真凶

2026-11-23 2 0

你有没有遇到过这种场景:服务上线时内存 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 在稳态负载下是否单调上升。看绝对值没意义,看曲线才有意义。


七、一套能落地的排查流程

  1. 先确认是真泄漏:HeapAlloc 趋势向上 + 流量稳定 + 业务指标没变,三者同时成立才算
  2. 看 goroutine 数:runtime.NumGoroutine() 打点画曲线。这个数不回落,八成是 goroutine 泄漏
  3. 抓 heap profile 两份对比:稳定态抓一份,内存涨 2 倍后再抓一份,用 go tool pprof -base 做差集,差集里谁在长,一目了然
  4. 查 Pool 和全局变量:sync.Pool、map 型全局缓存、闭包捕获的变量,是重灾区
  5. 审查所有 channel 的 select:每个发送都要有 ctx.Done() 分支,每个 consumer 都要能退出
  6. 加内存上限做兜底: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 拍得脸疼。

相关文章

你的 API 是给实习生写的?聊聊怎么设计一套 AI 能一次调对的接口
我把生产数据库换成 SQLite,账单砍掉九成,结果被一个文件锁教育了一整天
你的 async fn 忘了 await,一行代码都没跑:Rust 异步世界的七个真坑
你的 JWT 能不能撤销?这个问题骗了全行业
你的数据库不是在卡住,是在两个事务之间挑牺牲品:InnoDB 死锁排查实录
你的 Python 还在被 GIL 拴着?自由线程实测:单线程慢了 40%,但它敢让 CPU 真的跑满

发布评论