文章分析了Go服务内存飙升问题,指出Goroutine泄露是主要原因。通过pprof工具分析,发现大量Goroutine导致栈内存占用过多,且无法被垃圾回收。文章详细介绍了如何使用pprof抓取协程堆栈和排查代码陷阱,避免Goroutine泄露。
上个月排查一个在线推送网关的线上问题,服务刚发布时内存占用只有 180MB 左右,跑了三天之后一路飙升到了 4.6GB,宿主机直接触发了内存报警。
当时第一反应是堆内存里缓存没释放,或者哪里的切片一直在 append 没有清空。但诡异的是,业务低峰期哪怕每秒只有几十个请求,内存依然纹丝不动,GC 打印出来的内存回收量非常小。
运维同事建议加个定时任务每周重启一次服务。但我很清楚,这种内存缓慢增长的毛病,只要流量稍微一大,或者哪天遇到突发请求,往往会直接打崩整个容器,重启只是在逃避问题。
后来拉取线上 runtime 指标仔细看了一眼,发现问题根本不在常规的全局变量缓存上:runtime.NumGoroutine() 显示当前活跃的协程数量已经超过了 12 万个。
在 Go 语言里,一个新建的 Goroutine 初始栈内存虽然只有 2KB 左右,但当协程数量积累到几十万个时,光是栈空间就能吃掉上百兆。更要命的是,每一个卡死挂起的 Goroutine,闭包里引用的结构体、接收到的数据包以及堆上对象,全部无法被垃圾回收器释放。协程泄露往往伴随着堆内存泄露,这就是服务内存一路飙升且降不下来的根本原因。
排查并彻底解决这起事故的过程中,我遇到了几个日常写 Go 时极容易忽视的代码陷阱。这里把具体的排障命令和几个常见代码坑复盘一遍。
生产环境安全定位:用 pprof 抓取活跃协程堆栈
遇到疑似 Goroutine 泄露时,切忌盲目在本地猜代码。最快的排查路径是拿到线上实时的协程堆栈快照。
在业务服务初始化时,可以通过引入 net/http/pprof 暴露分析端点。需要注意的一点是,这个调试端口千万不能直接暴露在公网,建议单独绑定在内网管理端口或者通过本地端口转发访问:
package main
import (
"log"
"net/http"
_ "net/http/pprof"
)
func main() {
// 业务主逻辑...
// 独立启动管理端口供排障使用,避免暴露给外部网络
go func() {
log.Println(http.ListenAndServe("127.0.0.1:6060", nil))
}()
select {}
}
端点配好之后,排查 Goroutine 泄露主要依靠以下两条命令。
第一条是通过文本格式快速查看当前所有协程都在哪个函数阻塞:
# 查看按阻塞位置聚合的协程数量分布
curl -s http://127.0.0.1:6060/debug/pprof/goroutine?debug=1 | head -n 30
执行后输出的内容类似于:
goroutine profile: total 124580
123890 @ 0x43b2a5 0x44b12c 0x8a91c0 0x8a9b24 0x46e101
# 0x8a91c0 main.pushWorker+0x80 /app/service/pusher.go:42
# 0x8a9b24 main.handleMessage+0x64 /app/service/pusher.go:78
这里的数字非常扎眼:总共 12.4 万个协程中,有 12.38 万个都停留在 pusher.go 的第 42 行。这种高度聚集的调用栈,就是协程泄露的确定性证据。
第二条是把堆栈保存成 profile 文件,用 go tool pprof 进入交互式分析:
# 抓取协程快照到本地
go tool pprof http://127.0.0.1:6060/debug/pprof/goroutine
# 进入 pprof 命令行后,输入 top 命令按数量排序
(pprof) top
Showing nodes accounting for 123890, 99.45% of 124580 total
flat flat% sum% cum cum%
123890 99.45% 99.45% 123890 99.45% runtime.gopark
0 0.00% 99.45% 123890 99.45% main.pushWorker
# 查看具体的源码阻塞位置
(pprof) list main.pushWorker
通过这几行输出,立刻就能锁定引起泄露的具体代码块。结合实际代码审查,下面这几个坑在日常开发中最容易出现。
坑一:无缓冲 Channel 发送阻塞,超时退出后协程永久悬挂
这是日常代码里出现频率最高的一种泄露模式。很多同学为了实现接口超时控制,喜欢用 goroutine 配合 select 做并发请求,类似这样:
// 错误写法:超时后产生僵尸协程
func fetchUserInfoWithTimeout(ctx context.Context, uid int64) (*UserInfo, error) {
ch := make(chan *UserInfo) // 无缓冲 channel
go func() {
user, err := rpcCallUser(uid)
if err != nil {
return
}
// 当外层函数因超时提前返回时,这里再也没有接收方了
// 当前协程将永久阻塞在写入这一行,永远无法被 GC 回收
ch <- user
}()
select {
case res := <-ch:
return res, nil
case <-time.After(500 * time.Millisecond):
return nil, errors.New("request timeout")
}
}
分析一下执行过程:当下游 rpcCallUser 出现毛刺,耗时超过 500ms 时,外层函数触发了 time.After 分支并直接返回错误。
此时,无缓冲 channel ch 的读取方已经退出了。子协程执行完网络调用后尝试执行 ch <- user,由于通道没有缓冲区且再也没有人从里面读取,写操作永远无法完成。
这个子协程就会一直驻留在 Go runtime 的调度器中,它的调用栈和持有的 user 对象也永远得不到释放。每次接口超时一次,系统里就凭空多出一个僵尸协程。
修复方式有两种。最简单可靠的做法是将 channel 改为容量为 1 的缓冲通道:
// 正确写法:使用缓冲通道确保子协程安全退出
func fetchUserInfoWithTimeout(ctx context.Context, uid int64) (*UserInfo, error) {
ch := make(chan *UserInfo, 1) // 容量至少为 1
go func() {
user, err := rpcCallUser(uid)
if err != nil {
return
}
// 即便外层函数因超时退出,这里也能非阻塞地写入缓冲区,随后协程正常退出
ch <- user
}()
select {
case res := <-ch:
return res, nil
case <-time.After(500 * time.Millisecond):
return nil, errors.New("request timeout")
}
}
容量设为 1 之后,子协程写入数据时不会发生阻塞,函数正常执行完毕退出,Go 运行时随后会将 channel 和其中的数据一并回收。
坑二:for-select 循环中滥用 time.After(),隐蔽的定时器堆积拖垮堆内存
在我们的消息推送循环中,有一段原本打算用来做心跳检查的代码,写法大致如下:
// 错误写法:每次循环都生成新定时器
func processMessageQueue(msgChan <-chan Message) {
for {
select {
case msg := <-msgChan:
handle(msg)
case <-time.After(30 * time.Second):
// 超过 30 秒没消息时上报心跳
sendHeartbeat()
}
}
}
这段代码初看非常正常:如果队列里 30 秒没有消息,就发一次心跳。但在高并发场景下,它会带来巨大的堆内存压力。
time.After(d) 的底层实现是调用 time.NewTimer(d) 并返回其中的 C 通道。问题在于:每当 msgChan 收到一条消息,select 就会命中第一条分支并结束本轮等待,开启下一次 for 循环。
然而,上一轮循环中被创建出来的 time.Timer 并没有被废弃,它依然在底层的定时器堆中等待 30 秒倒计时结束。如果系统每秒处理 1000 条消息,在 30 秒的时间窗口内,内存里就会同时堆积 30000 个未触发的定时器对象。每个定时器都会连带绑定一个未退出的运行时通道,造成大量的堆内存碎片与协程调度负担。
正确的做法是在循环外部复用同一个 Timer 对象,每次处理完消息后重置它:
// 正确写法:复用单个 Timer 避免对象堆积
func processMessageQueue(msgChan <-chan Message) {
timer := time.NewTimer(30 * time.Second)
defer timer.Stop()
for {
select {
case msg := <-msgChan:
handle(msg)
// 收到消息后重置定时器
if !timer.Stop() {
select {
case <-timer.C:
default:
}
}
timer.Reset(30 * time.Second)
case <-timer.C:
sendHeartbeat()
timer.Reset(30 * time.Second)
}
}
}
通过复用同一个定时器,内存中永远只有一个 timer 实例,彻底避免了高频请求下的定时器堆积现象。
坑三:context.WithTimeout 漏写 defer cancel(),定时器资源无法及时释放
在微服务调用中,我们经常使用 context.WithTimeout 传递超时限制。但有一处代码写得十分随意:
// 错误写法:忽略 cancel 函数
func batchQueryData(items []int64) {
for _, item := range items {
ctx, _ := context.WithTimeout(context.Background(), 5*time.Second)
doRemoteQuery(ctx, item)
}
}
很多人以为只要时间到了 5 秒,或者下游请求已经正常返回了,这个 context 就会自己消亡,所以就把返回的 cancel 函数用下划线丢掉了。
实际上,context.WithTimeout 会在内部注册一个全局定时器。如果远程查询在 50ms 内就顺利完成了,但因为没有主动调用 cancel(),内部挂载的定时器必须硬生生等足 5 秒钟才会触发销毁。
如果这个循环处理的数据量很大,短时间内就会有成千上万个超期未销毁的 context 节点挂在父上下文中,同样会造成协程堆栈与定时器对象的滞留。
正确的写法是把每一次派生出的上下文用匿名函数隔离,或者在单次循环内部立刻调用 cancel:
// 正确写法:及时调用 cancel 释放资源
func batchQueryData(items []int64) {
for _, item := range items {
func() {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel() // 无论成功还是失败,函数退出时立即清理定时器
doRemoteQuery(ctx, item)
}()
}
}
只要调用了 cancel(),Go 运行时就会立刻从时间堆中摘除这个定时器,切断上下文引用关系,内存便能即刻被 GC 识别。
坑四:HTTP Client 响应体未读完就直接 Close,底层连接与协程无法复用
排查日志时,我还发现了大量未关闭的 HTTP 连接,对应的代码大致是这样:
// 错误写法:Body 没读完直接关闭
resp, err := httpClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
// 发现状态码不对直接退出
return fmt.Errorf("bad status: %d", resp.StatusCode)
}
// 正常解析数据...
很多人知道写 defer resp.Body.Close(),但在遇到非 200 状态码或者只读取部分数据的场景下,如果响应体里的字节没有被完全读尽,直接调用 Close 会导致一个严重后果:底层 TCP 连接无法放回 http.Transport 的连接池中复用,连接会被强制重置。
更糟糕的是,标准库的 Transport 在维持每个连接时,都会在后台运行专用的 readLoop 和 writeLoop 协程。当连接无法正常归还且由于对端未完全关闭连接时,这组读写协程会短暂停留,甚至在超时等待期间长期存活。当大量异常请求涌入时,未正常回收的读写协程就会成倍增加。
在放弃处理或者只读部分内容时,标准的排错做法是在 Close 前把残余字节丢弃掉:
// 正确写法:丢弃未读完的数据后再关闭
resp, err := httpClient.Do(req)
if err != nil {
return err
}
defer func() {
// 耗尽响应体数据,确保连接能够安全放回连接池
io.Copy(io.Discard, resp.Body)
resp.Body.Close()
}()
加上这一步后,TCP 连接能够被可靠复用,Transport 后台的协程池规模也能保持在稳定水平。
防御方案:在单元测试中接入 goleak 阻断协程泄露
生产环境排查泄露固然有效,但如果能把这类问题拦截在上线前,成本会低得多。
Uber 开源了一个名为 goleak 的测试工具,可以检测测试用例运行结束后是否有未退出的非预期协程。引入方法非常直接:
go get -u go.uber.org/goleak
在相关的包测试文件中,只需要在测试入口加上验证函数:
package service
import (
"testing"
"go.uber.org/goleak"
)
// 对整个测试包执行泄露检查
func TestMain(m *testing.M) {
goleak.VerifyTestMain(m)
}
// 单个测试用例中验证
func TestFetchUserInfo(t *testing.T) {
defer goleak.VerifyNone(t)
// 运行你的并发业务逻辑
_, err := fetchUserInfoWithTimeout(context.Background(), 10001)
if err != nil {
t.Log(err)
}
}
一旦用例执行结束后存在残留的挂起协程,goleak 会直接让用例失败,并打印出具体泄露协程的完整堆栈。把它接入到团队的自动化测试流水线里,绝大多数无缓冲 channel 卡死和未 cancel 上下文的低级错误都能在合代码阶段被揪出来。
把上面提到的无缓冲 channel 增加容量、Timer 复用以及 HTTP Body 排空逐一修复后,我们重新打包推送上线。观察了整整一周,常驻 Goroutine 数量稳定在 300 到 500 个之间,服务内存长期保持在 220MB 上下,再也没有出现过逐步爬升的情况。
文章标题:Go 服务内存飙升不降?排查 Goroutine 泄露与 pprof 分析我踩过的几个坑
文章链接:https://www.llbbs.cn/jishujaocheng/331.html
本站文章均为原创,未经授权请勿用于任何商业用途
评论一下?