一个跑了三天的服务,内存从 40MB 涨到 300MB,重启之后立刻回到 40MB,然后继续缓慢上涨。CPU 不高,QPS 稳定,日志里也没有错误。把运行时指标拉出来,最刺眼的是 goroutine 数量:启动时几十个,现在四千多个,而且只增不减。
这类问题的学名叫 goroutine 泄漏。它不会崩溃,不会报错,只是慢慢把内存吃掉,最后在某次流量高峰时 OOM。最难受的是本地很难复现,因为本地请求量小、进程活不过几分钟,泄漏的那点量根本看不出来。
这篇讲四件在真实项目里反复出现的事:goroutine 怎么调度、为什么会被泄漏;defer 到底什么时候执行、在循环里会出什么问题;接口的 nil 为什么和你以为的不一样;错误该怎么包装和判断,panic 又该在什么时候用。这四件事互相关联,泄漏往往和没取消的等待有关,而错误处理的写法又决定了你能不能及时发现它。
一百个 goroutine 卡在发送上
先复现一个最小版本的泄漏。创建一个无缓冲 channel,起一百个 goroutine 往里写,但没有任何人读:
ch := make(chan int)
for i := 0; i < 100; i++ {
go func(id int) { ch <- id }(i)
}
time.Sleep(200 * time.Millisecond)
fmt.Println("goroutine 数:", runtime.NumGoroutine())
本机 go1.27.3 实测输出是 goroutine 数: 101,也就是主 goroutine 加一百个被阻塞的 goroutine。它们不会自己消失,因为无缓冲 channel 的发送必须等到有人接收。只要接收方永远不出现,这一百个 goroutine 就永远停在那一行,栈、变量、引用全都被保留着。
真实项目里的版本更隐蔽:一个后台任务从 channel 读任务,但 channel 从不关闭;或者一个 goroutine 在等一个只在自己退出时才关闭的 channel;或者网络请求没有设超时,读操作永远等不到数据。它们的共同点是「等待一个没有终点的事件」。
context,并约定由创建者负责取消。第 8 篇会专门讲 context 的取消树。定位泄漏最直接的证据是 goroutine 快照。服务如果挂了 net/http/pprof,可以用 go tool pprof 打开堆栈文件,按函数聚合,一眼就能看到几百个 goroutine 停在同一行。线上不方便连调试端口时,周期性打印 runtime.NumGoroutine() 也能看出趋势。要注意数量高不一定是泄漏,稳定在高位可能只是工作池的正常规模,关键是它会不会随着请求结束回落。
goroutine 不是线程,但也不是免费的
goroutine 是 Go 运行时管理的执行单元。你写 go f(),运行时创建一个小任务,把它放到某个处理器的本地队列里,等操作系统线程来取。它和操作系统线程不是一对一的关系:少量线程可以轮流执行大量 goroutine。
这套 G-M-P 模型的价值在于把「任务切换」从内核搬到用户态。操作系统线程切换要进内核、保存寄存器、刷新缓存,成本高;goroutine 切换大部分时候只是换一个栈和几个寄存器。所以同样一台机器,Go 能同时挂着几万个等待中的 goroutine,而线程模型早就撑不住了。线程调度本身的原理可以对照 操作系统:线程与调度 那一篇看。
但「便宜」不等于「免费」。每个活着的 goroutine 都要占一块栈内存,被阻塞的 goroutine 还会持有它引用的对象,让垃圾回收器没法回收。CPU 密集的任务也不会因为开了更多 goroutine 而变快,它们最终还是要抢那几个 P。runtime.GOMAXPROCS(0) 返回当前可同时执行的数量,本机是 12,和 CPU 核数一致。
所以正确的用法是:I/O 等待密集的任务,可以开很多 goroutine;纯计算任务,开超过 GOMAXPROCS 的数量只会增加调度开销。无限制地「一个请求一个 goroutine」在流量突增时同样会把内存打满,生产环境通常还要加信号量或工作池。
defer:参数现在算,清理最后做
defer 的作用是把一个函数调用推迟到当前函数返回之前执行。它最常见的用途是释放资源:关文件、解锁、关闭连接。它有两个容易被忽略的规则。
第一,defer 后面的函数参数在 defer 语句执行的那一刻就求值了,真正调用发生在函数返回时。第二,多个 defer 按后进先出的顺序执行。本机实测:
func body() {
fmt.Println("函数体开始")
for i := 0; i < 3; i++ {
defer fmt.Println("循环里的 defer, i =", i)
}
defer fmt.Println("defer A")
deferred := func() { fmt.Println("defer B") }
defer deferred()
fmt.Println("函数体结束")
}
函数体开始
函数体结束
defer B
defer A
循环里的 defer, i = 2
循环里的 defer, i = 1
循环里的 defer, i = 0
输出里循环的三个值分别是 2、1、0,而不是三个 2。因为每次执行 defer 语句时,i 的当前值已经被复制进延迟调用的参数里,函数返回时只是按顺序把这些调用发出去。
defer 还能修改返回值,但只对命名返回值有效。无名返回值在 return 那一刻已经把值拷贝到返回位置,defer 再改变量也影响不了结果。本机对比:
func named() (n int) {
defer func() { n++ }()
return 5
}
func unnamed() int {
n := 5
defer func() { n++ }()
return n
}
命名返回值: 6
无名返回值: 5
这个差别在正常业务里很少用到,但在「defer 里 recover 并修改返回错误」的写法中很关键。如果你的函数签名是 func f() error,defer 里想把返回值改成包装后的错误,就必须写成 func f() (err error)。
最常见的误用是在循环里 defer。defer 不会在当次循环结束时执行,而是全部堆到函数返回。循环一万次就注册一万个延迟调用,期间打开的文件、连接、锁全都不释放,很容易把句柄耗尽。解决办法很简单:把循环体抽成一个独立函数,让 defer 跟着那次调用结束。
for _, p := range paths {
if err := processOne(p); err != nil {
return err
}
}
func processOne(p string) error {
f, err := os.Open(p)
if err != nil {
return err
}
defer f.Close()
// 处理这个文件
return nil
}
还有一个小坑:defer f.Close() 丢掉了 Close 的返回值。读文件时通常无所谓,写文件时 Close 可能才把缓冲区刷盘,失败了你却不知道。写文件的正确做法是显式 Close 并检查错误,或者在 defer 里记录错误。
接口的 nil,不是指针的 nil
第 1 篇提过接口内部是「动态类型加动态值」。这个结构直接导致一个高频 bug:函数返回 error,内部把一个值为 nil 的具体错误指针装进了接口,调用方判断 err != nil 成立,于是走进错误分支,打印出来却是空。
type NotFoundError struct{ ID int }
func (e *NotFoundError) Error() string { return fmt.Sprintf("用户 %d 不存在", e.ID) }
func find(id int) error {
var e *NotFoundError
if id > 0 {
return nil
}
return e
}
err := find(0)
fmt.Println("err == nil:", err == nil)
fmt.Println("err != nil:", err != nil)
err.Error()
本机实际输出:
err == nil: false
err != nil: true
panic: runtime error: invalid memory address or nil pointer dereference
前两行已经说明问题:接口不等于 nil。第三行调用 Error() 时,方法接收者是 nil 指针,方法体里访问 e.ID,立刻空指针 panic。更麻烦的是,如果这个方法不访问字段,只返回一个常量字符串,它就不会 panic,而是安静地返回一段看起来正常的错误信息,让你以为真的出了那个错。
修法有三条:返回前判断具体指针,为 nil 就返回字面量 nil;用值类型而不是指针实现 error;调用方用 errors.As 取出具体类型后再判断。最不推荐的是用 reflect 判断接口底层值是否为 nil,那种写法可读性差,还容易漏掉嵌套情况。
顺带说清方法集:值接收者的方法,值类型和指针类型都能调用;指针接收者的方法,只有指针类型能调用。把值类型装进接口时,接口里存的是一份副本,之后改原变量不会影响接口里的值。这也是为什么含锁的结构体不能按值传给接口,复制出来的锁和原来的锁保护的不是同一份数据。
error 是值,包装是为了保住判断能力
Go 的 error 就是一个普通接口,只要求一个 Error() string 方法。函数把错误作为最后一个返回值传出来,调用方必须显式判断。没有异常,没有隐式跳转,也不会因为漏写 try 而让错误悄悄消失。
但「每个函数都返回 error」带来一个新问题:错误从底层传到顶层,途中要加信息,又不能丢失原始错误,否则上层没法判断到底是「记录不存在」还是「数据库连不上」。Go 1.13 引入的包装解决了这件事:fmt.Errorf("...: %w", err) 用 %w 把原错误包进去,形成一条链;errors.Is 沿链查找某个哨兵错误,errors.As 沿链查找某个具体类型。
var ErrNotFound = errors.New("记录不存在")
func load(id int) error {
if id == 0 {
return fmt.Errorf("load(%d): %w", id, ErrNotFound)
}
return nil
}
err := load(0)
fmt.Println(err)
fmt.Println("errors.Is:", errors.Is(err, ErrNotFound))
本机实际输出:
load(0): 记录不存在
errors.Is: true
如果把 %w 换成 %v,日志看起来一模一样,但包装链断了,errors.Is 返回 false。这是最常见的「明明包了错误却判断不到」的原因,排查时先看用的是不是 %w。
自定义错误类型只要实现 Unwrap() error,就能参与这条链。errors.As 会逐层检查动态类型,找到就把值写进你传的指针。注意第二个参数必须是指向「错误类型」或「接口」的指针,传错类型会 panic。
包装也要克制。每一层都加一句「调用 xxx 失败」,最后日志里会出现七八层前缀,真正有用的信息被埋掉。通常只在跨越模块边界时包装一次,同一模块内部直接返回原错误。包装文本里不要放密码、令牌、完整请求体,错误日志经常被收集到第三方平台。
标准库从 1.20 起提供了 errors.Join,可以把多个错误合成一个,errors.Is 会在每个分支里查找。它适合「关闭多个资源、每个都可能失败」的收尾场景,比只返回最后一个错误更完整。另外,哨兵错误一旦被外部包用 errors.Is 判断,就等于写进了公开接口,改它的提示文本没关系,换掉变量本身会破坏调用方。
panic 和 recover 的真实边界
panic 是程序遇到无法继续的状态时主动中止的机制,recover 只能在 defer 里调用,用来截住当前 goroutine 的 panic。它有一个硬边界:不能跨 goroutine。在子 goroutine 里 panic,主 goroutine 的 recover 完全接不到,整个进程会退出。
func main() {
defer func() {
if r := recover(); r != nil {
fmt.Println("主 goroutine 捕获:", r)
}
}()
go func() { panic("子 goroutine 出错") }()
time.Sleep(time.Second)
fmt.Println("主 goroutine 正常结束")
}
本机实际输出(省略了调用栈中间部分):
panic: 子 goroutine 出错
goroutine 7 [running]:
main.main.func2()
...
exit status 2
「主 goroutine 正常结束」这句话根本没打印,主函数里的 defer 也没能改变结局。所以每个自己起的 goroutine,如果内部可能 panic,都要在自己的 defer 里 recover,或者确保它只做不会 panic 的事。
error:可预期的失败
文件不存在、参数不合法、下游超时、余额不足。这些是业务流程的一部分,调用方应该能判断并处理。用返回值传递,必须显式检查。
panic:不该发生的状态
数组越界、空指针、代码违反了自身假设。这类问题说明程序有 bug,继续跑只会产生更奇怪的数据。让它尽快暴露,比吞掉更好。
实际项目里的惯例是:库函数不主动 panic,除非参数错误属于程序员使用错误且无法用 error 表达;服务入口处可以放一层 recover 做兜底,记录堆栈并返回 500,但不要用它来当正常控制流。recover 之后函数不会从 panic 的那一行继续执行,它只是停止 panic 的展开,然后照常返回。
还有一点:panic 发生时,当前 goroutine 已经注册的 defer 会依次执行。所以「先 defer 解锁,再 panic」不会把锁永远留在手里。但如果是进程被强杀,defer 不会执行,数据库事务、临时文件这些清理不能只依赖 defer。
出问题时先看哪里
这四类机制的故障表现差别很大,下面这张表按现象给出第一步的检查方向。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| goroutine 数只涨不降,内存缓慢上升 | goroutine 阻塞在 channel、锁或没有超时的网络读上 | 用 runtime.NumGoroutine 看趋势,再抓 goroutine profile 看栈停在哪一行 |
| fatal error: all goroutines are asleep - deadlock | 所有 goroutine 都在等,没有任何一个能推进 | 看栈里最后一个 chan send 或 chan receive,找配对的接收方或发送方 |
| 循环里打开文件越来越多,句柄耗尽 | defer 堆到函数返回才执行,循环期间不释放 | 看 defer 是否写在 for 里面;把循环体拆成独立函数 |
| defer 里改了返回值却没生效 | 函数用的是无名返回值,return 时已经拷贝 | 看函数签名是否有命名返回值 |
| err != nil,但打印出来是空 | 装进接口的是值为 nil 的具体指针 | 用 %T 打印动态类型;返回前判断具体指针 |
| errors.Is 判断不到自定义错误 | 包装时用了 %v,或自定义类型没实现 Unwrap | 检查格式化动词;检查错误链是否完整 |
| recover 没接住 panic | panic 发生在另一个 goroutine,或 recover 不在 defer 里 | 看崩溃栈的 goroutine 编号;确认 recover 的位置 |
| 写文件成功但内容为空 | Close 或 Flush 失败,返回值被 defer 忽略 | 显式调用 Close 并检查错误,必要时调用 Sync |
排查 goroutine 泄漏有一个很实用的顺序:先看数量趋势,确认是持续增长还是启动时就很高;再抓一份 profile,按栈聚合,通常一眼就能看出是哪段代码卡住;最后回到那段代码,找「谁负责让它退出」。如果没人负责,那就是设计问题,不是参数调优能解决的。
边界与代价
- goroutine 的便宜有上限:阻塞的 goroutine 仍占栈和引用,数量到几十万时内存和调度都会吃紧。不要用「反正 goroutine 便宜」当理由取消并发限制。
- defer 不是零成本:现代编译器对简单 defer 做了优化,但循环里成千上万次注册仍会累积。热路径上如果 defer 只包一个原子操作,直接写往往更划算。
- 接口带来抽象,也带来分配:把具体类型装进接口可能触发堆分配,调用要走动态派发。接口应该出现在模块边界,不是每个内部函数都套一层。
- 错误链会变长:包装次数太多,日志难读,
errors.Is也要逐层走。约定只在跨层时包装,并在包装文本里写清楚「做了什么、失败了什么」。 - recover 不是安全网:它接不住其他 goroutine 的 panic,也接不住运行时直接终止进程的致命错误。真正的兜底是进程级监控和快速重启。
- 没有异常让错误容易漏:编译器不强制你检查返回值,漏写
if err != nil照样能编译。用errcheck这类静态检查工具,比靠自觉可靠。
这些机制的设计取向是一致的:把隐式行为降到最低,把代价摆到明面上。goroutine 要你自己管生命周期,defer 要你自己注意位置,错误要你自己判断。写起来比异常体系麻烦,但出问题时栈和错误链能直接告诉你发生了什么。
当天能自己验证的练习
- 起一百个 goroutine 往无缓冲 channel 写,不接收,打印
runtime.NumGoroutine();再起一个接收循环把值读掉,观察数量回落。注意读完之后 goroutine 才会退出。 - 写三个 defer 加一个循环里的 defer,确认执行顺序是后进先出,并观察循环变量被固定在注册那一刻的值。
- 分别写命名返回值和无名返回值的函数,在 defer 里自增,打印结果,确认只有命名返回值被改变。
- 用
%w包装三层错误,errors.Is应该命中;把其中一层改成%v,再跑一次,确认判断失败。 - 在子 goroutine 里 panic,主 goroutine 用 defer recover,运行后确认进程仍然退出、主函数的收尾代码没有执行。
小结
三句话收一下:goroutine 由运行时调度,创建便宜但阻塞的 goroutine 会一直占资源,泄漏要靠取消信号而不是记忆来防;defer 的参数在注册时求值、调用在返回时执行,循环里用会把清理推迟到不可接受的程度;error 是普通接口,用 %w 包装才能保住 errors.Is 和 errors.As 的判断能力,panic 只适合真正的程序错误,而且接不住别的 goroutine。
下一篇进入标准库。今天你已经用到了 fmt、time、errors,但真正天天打交道的还是字符串、切片、map、时间和 JSON。尤其是切片:append 什么时候复用底层数组、什么时候重新分配,直接决定你会不会遇到「改了一个变量,另一个也变了」的怪事。