recover 只在 defer 里管用,别的地方都不行

难度 ★★★☆☆ · 前置:errors.Is 和 errors.As 到底在翻什么 | 一句话结论:recover 只在被 defer 挂着的那一层管用,它摘下来的是整条往上爬的传播链,不是把执行点送回崩溃的那一行,接住之后这一层就正常返回了。

终端最后留下来的是一行 panic: 手动 panic,下面接着一整屏 goroutine 栈,退出码不是 0。第一次见到这屏是在一个跑批服务上,那天我在改别的东西,群里说任务挂了,登上去翻日志,出事点之前的业务日志一条不少,之后什么都没有,就剩这一屏。我没先去读栈,往入口套了一层 defer,把 recover 写进去,以为这下安全了,结果崩的那个 goroutine 是我在循环里起的,入口那层从头到尾都没被惊动。后来我又在一个工具函数里写了一次 recover,想着哪里出事都能兜住,运行起来进程照样退出,因为那个函数压根没被 defer 挂在栈上。

三处错误,一处是位置错了,一处是范围小了,还有一处是我压根没搞清到底谁在崩。那屏我复制成文本文件反复翻过,最上面是 panic 的值,下面一长串是各个 goroutine 的状态,翻到中段才认出那个循环里的匿名函数。这份文件我留到现在,隔一阵还会拿出来看看。我把它按时间戳排过一次,最先出事的那一行压在最底下,跟我打开它的顺序正好反着。

兜不住的原因不止一个,我索性把六种情形拆成单独的小程序,一个一个跑,把 recover 拿到的东西连同它的类型原样打出来。位置比写法要紧。

六种崩溃被同一个 defer 接住了

六种崩溃我摆进同一个程序里跑。

程序很短,一个 main 就够。做一个 try 函数,函数里 defer 一个闭包,闭包里直接调 recover,拿到值就打印。六种情形各自包成一个匿名函数传进去,手动 panic 一段文本、panic 传 nil、panic 传一个 errors.New 造出来的错误、切片越界、空指针解引用、整数除以零,六次调用依次跑完,最后再打一行,用来看主流程有没有活下来。recover 那一段我特意加了个分支,只有值是 *runtime.PanicNilError 的时候才把类型也打出来,因为我一开始根本不信那个 nil 会变成真实的错误值。六种情形跑完只用了几秒,输出一共七行,可这七行我对着看了很久,因为其中有几行的长相跟我预期差得太远。

位置和类型,这两条我是分开记的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main

import (
"errors"
"fmt"
"runtime"
)

func try(name string, f func()) {
defer func() {
r := recover()
if r == nil {
return
}
if p, ok := r.(*runtime.PanicNilError); ok {
fmt.Printf("%s: %v (类型 %T)\n", name, p, p)
return
}
fmt.Printf("%s: %v\n", name, r)
}()
f()
}

func main() {
try("普通 panic", func() { panic("手动 panic") })
try("recover 拿到", func() { panic(nil) })
try("捕获错误", func() { panic(errors.New("业务错误")) })
try("越界", func() {
s := []int{1, 2, 3}
_ = s[5]
})
try("空指针", func() {
var p *int
_ = *p
})
try("除零", func() {
a := 0
_ = 10 / a
})
fmt.Println("主流程继续")
}
1
2
3
4
5
6
7
普通 panic: 手动 panic
recover 拿到: runtime error: panic called with nil argument (类型 *runtime.PanicNilError)
捕获错误: 业务错误
越界: runtime error: index out of range [5] with length 3
空指针: runtime error: invalid memory address or nil pointer dereference
除零: runtime error: integer divide by zero
主流程继续

六个情形我连着跑了三回,输出没变过。把七行按谁按的开关重新排一遍,关系就清楚了:

情形 谁按的开关 recover 拿到的值
panic("手动 panic") 我 那段文本
panic(nil) 我 *runtime.PanicNilError
panic(errors.New(...)) 我 那个 error 值
切片越界 运行时 index out of range [5] with length 3
空指针解引用 运行时 invalid memory address or nil pointer dereference
整数除以零 运行时 integer divide by zero

第一件能确认的事是这六次崩溃全被同一个 defer 接住了,进程没有退,最后那行也确实打了出来。

六次调用里只有第一次是我自己按的开关,后面五个都是运行时替我按的,可它们走的是同一条路,defer 一样跑,recover 一样拿到值,外面一样看不出区别。这一点当时让我有点意外,因为我一直把越界和空指针当成另一种故障,以为它们会换个机制直接把进程带走,跟 panic 不是一回事。实际跑过才知道它们只是 panic 的另一个来源,来源不同,传播方式一模一样,我这六次调用连抛出位置都没出过第二层,全是在传进去的那个匿名函数里当场炸的。我原来那套把主动抛和运行时抛分开对待的想法,在这里没什么用。

来源不同,路是同一条。

(这一节本来想放前面,试排了一下,读着像在绕,又挪回这儿了。)

另一个细节在类型那一栏,留到后面单独说。先说位置,因为位置才是我最早写错的地方,也是最不值钱的一处错,翻一下文档就能改过来,代价只是我当时不知道去哪儿翻。

写在普通函数体里的 recover 只是普通调用

recover 不看文件名,也不看你调了几次,它看的是调它的那个函数此刻是不是正被 defer 挂在栈上。写在普通函数体里,它就是一次普普通通的调用,返回 nil,因为没有任何正在传播的 panic 从它身上经过。我试过两种错法,第一种是在 defer 的闭包里再调一个帮忙函数,recover 写在帮忙函数里,隔了这么一层,拿到的还是 nil,日志里连一行都没打出来。第二种更直白,把 recover 写在一个普通方法里,这个方法被调的时候压根没人 panic,它自然也是 nil,而我还对着这个 nil 检查了半天参数顺序。位置对了以后,后面这些细节才有讨论的意义,位置错了,怎么写都是空谈。

1
2
3
4
5
6
7
8
9
10
func peek() any {
return recover() // 隔了一层,这里拿不到值
}

func wrong() {
defer func() {
fmt.Println(peek()) // nil
}()
panic("手动 panic")
}

反过来就对了,把 recover 直接摆在 defer 的那个函数体里,中间不转手,值就能拿到,差别在代码里看着小得可怜。

1
2
3
4
5
6
7
8
func right() {
defer func() {
if r := recover(); r != nil {
fmt.Println("接住了")
}
}()
panic("手动 panic")
}

它只认挂着它的那一层。这条规则听着抠门,其实有它的道理。recover 要做的事是把一个还挂在栈上的 panic 摘下来,它必须知道自己站在哪一层,才能把控制权交回到这一层的边界上。中间转了一道手,它就没有这个位置了,只能老实回一个空值。我后来还见过一个更隐蔽的错法,有人把 recover 写在一个被 defer 调用的方法里,方法本身还带指针接收者,跑起来照样是 nil,因为隔的那一层跟接收者是值还是指针没有关系,跟调用深度有关系。写在普通函数体里,为什么一句都不管用?

defer 后进先出,注册和拆除反着来

先把顺序这件事拆干净。

一个函数里写三个 defer,执行的时候从最后一个开始,跑完倒数第二个,再跑第一个,注册的顺序和拆除的顺序正好反过来。正常返回的时候这只是个小知识,轮到 panic 的时候它变成主线,因为栈是一层一层往外塌的,每一层塌到自己的时候才去跑自己那串 defer,而每一串内部又是从最后注册的那个开始。两条规则叠在一起,效果就是最先注册的收尾动作最后才轮到,谁申请得早谁活得久。这个顺序跟资源本身的依赖关系对得上,你先开的文件当然得后关,后拿的锁当然得先放。

栈是从里往外拆的。

这个顺序不是运行时随手定的,它保证的正是这层依赖,后面注册的那一行通常用着前面那一行留下来的东西,所以它得先走。

1
2
3
4
5
6
func order() {
defer fmt.Println("先注册的")
defer fmt.Println("中间注册的")
defer fmt.Println("后注册的")
panic("手动 panic")
}

panic 往上爬,每层都跑一遍自己的 defer

defer 从里往外拆,panic 逐层往外传

那张图后来是我自己画的。

一个函数里 panic 之后,这个函数剩下的语句一条都不执行了,控制流不往下走,直接拐进 defer 那条路,把这层的 defer 从后往前跑完,然后往上一层传。上一层收到的是一个已经抛出来的 panic,它自己剩下的语句同样不执行,同样只跑自己的 defer,跑完再往上传。整个过程像剥洋葱,从最里面那层开始,一层一层往外,每层都把自己那串收尾跑完才交给上一层。如果你在每层的 defer 里各打一行日志,输出里的顺序会是从里到外,跟函数调用的顺序正好反过来,第一次看到这个倒序的人多半会怀疑是打印的缓冲出了问题。那张图我对着日志看了很久才画出来。这条传播路线上谁都没机会说一句我不接,除了 defer 里的 recover,别的地方插不进手,也不存在什么全局的兜底开关。每一层都只跑自己的那串 defer,跑完把剩下的交上去,谁也替不了谁收尾。

接住之后从那一层返回,回不到崩的那一行

接住之后发生了什么,值得单独摆出来看。

这是最容易误解的一处。某一层的 defer 里 recover 成功,panic 就停在那一层,不再往上传,那一层的调用方完全不知道底下发生过什么,它只是看到这个函数正常返回了。注意是那一层返回,不是从 panic 的位置接着往下执行,崩掉的那个函数里 panic 后面那些语句永远不会跑,你接住的只是这次传播,不是那段代码。我一开始以为 recover 等于一个跳转,能跳回出事那行下面接着走,实际站位完全不是这样,它站在 defer 里,而 defer 是这层函数退出前最后跑的东西,它能决定的只有这一层怎么退出,改不了这一层已经执行到哪儿。

接住只是收尾,不是把执行点挪回去。

1
2
3
4
5
6
7
8
9
func half() (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("这一层接住了: %v", r)
}
}()
panic("手动 panic")
return nil
}

抓得住不代表改得动。这句话的意思是,你接住的是一个已经发生的事实,程序里被改坏的状态不会因为接住就复原,所以 recover 之后能做的往往是收尾和报错,不是假装没发生,更不是从这层里再往下走一步。

panic(nil) 现在包成了 PanicNilError

我原本以为 panic(nil) 之后 recover 拿到的是 nil,然后会被误判成没出事。实际打印出来那一行写的是 runtime error: panic called with nil argument,后面括号里的类型是 *runtime.PanicNilError。也就是说传进去的 nil 被包了一层,变成一个真实的错误值,这个改动是为了让人分得清确实有人调了 panic,还是别的原因让 recover 返回了空。要是它原样给一个 nil,你就没法判断这次是有人 panic 了一个空值,还是你自己的 defer 压根没生效,两种情况的处理完全不一样,前者是一个真的崩溃点,后者是代码写错了位置。(这一节我头一版写的是 panic(nil) 现在拿不到 nil 了,读着顺,可重点跑偏了,它给出来的是包过一层的东西,不是空值,重写。)

这个包装是运行时做的,你在代码里敲 panic(nil) 的时候看不出任何异样,编译器不拦,只有跑起来才看到那个类型。那条把 nil 当成没出事的路,现在是堵着的。

越界、空指针、除零也是 panic

输出里那三行运行时错误,是拿三段最短的代码跑出来的:

干了什么 recover 里拿到的那句原文
取下标越界 index out of range [5] with length 3
走空指针 invalid memory address or nil pointer dereference
整数除零 integer divide by zero

三句都是运行时自己的原文,不是我编的描述,它们在 recover 里就是普通的值,类型也是运行时那几个错误类型。这件事的意义在于,recover 除了接住我主动 panic 的东西,也接得住那些我没打算 panic 的 bug。反过来说,如果在 defer 里把所有运行时错误一股脑吞掉,那些本该暴露的越界和空指针就被按住了,进程活着,数据可能已经错了一半,而且这类错误本来就不该在一次正常请求里出现。我现在的判断是运行时错误一律不接,接了就等于把一条本该打断的线索自己剪掉,日志里只剩一句不知道从哪来的恢复信息。吞下去容易,查起来难。

goroutine 崩了,外面的 recover 够不着

这个坑我踩得最惨,记了最久。

一个 goroutine 里 panic,外面那个 defer 接不住,哪怕你把 recover 写在 main 里也一样。每个 goroutine 有自己独立的栈,它崩的时候展开的是自己那串栈帧,跑的也是自己那串 defer,main 那条栈跟它没有关系,所以它接不到。这个坑我踩过一次,我起了一个 goroutine 去处理上传,主流程外面套了 recover,以为万无一失,结果那个 goroutine 出问题的时候进程还是退了,因为崩的是它自己的栈,外面那层根本没被展开到。

这段栈怎么看都缺一块东西。

如果一直没人 recover,程序会把 panic 的值和整条 goroutine 栈打出来,然后以非零退出码收场,日志里那段栈就是它留下的现场。

所以正当的用法是有边界的。我现在只在进程入口和框架处理单个请求的那一层留 recover,崩了就把这次请求转成 500,记一条带栈的日志,进程继续跑后面的请求,别的层我不放。

这种用法的前提是这次崩溃的代价只落在这一个请求上。如果你的 goroutine 正在改一个共享的结构,接住之后那个结构可能已经改坏了一半,接着跑比崩了更糟。先崩比带病跑好这句话我说得挺干脆,可有一件事我没验证完:goroutine 崩掉以后,那段栈里能不能看出它是谁起的。我试过几回,日志里只有栈帧,没有起点的信息,也可能是我不会看,这一个我到现在也没搞明白。