Go panic 与 recover

平时运行 Go 程序时,如果遇到切片下标越界、向未初始化的 nil Map 存入数据或访问空指针指向的值,程序就无法继续往下执行了。此时控制台会打印出一行以 panic: runtime error 开头的报错信息,随后整个程序立即终止。

对于普通可预见的业务问题,Go 语言统一将 error 作为函数返回值传递。而遇到程序无法继续往下运行的严重错误时,就会触发 panic 中断程序,其中 panic 是英文 “恐慌” 的意思。

针对这种致命异常,Go 语言还提供了配套的 recover() 函数(意为 “恢复”)。我们可以在延迟函数中调用它来拦截 panic,避免整个主程序直接崩溃退出。

触发 panic 异常

在 Go 语言中,触发 panic 主要有两种情况:一种是遇到切片越界、除以 0 等严重运行时错误,由 Go 运行时系统自动触发;另一种是我们在代码中主动调用内置的 panic() 函数来触发。

语法:

panic(错误信息)

说明:

panic() 函数的参数可以是任意类型的值,平时一般传入描述原因的字符串或 error 值。一旦某一行代码触发了 panic,程序会严格按照以下规律执行:

  • 当前函数后续代码立即停止:位于 panic 语句下方的普通代码不会再执行。
  • 已登记的 defer 照常执行:退出当前函数之前,系统会先将 panic 发生前已经通过 defer 语句登记好的延迟操作,按 “后进先出” 的顺序全部执行完毕。
  • 向上层调用方逐层中断:如果一直没有被拦截恢复,程序最终会在控制台打印出错误原因与调用堆栈,然后终止整个程序。

示例 1:主动调用 panic()

package main

import "fmt"

func main() {
    fmt.Println("1. 程序开始启动")
    panic("数据库连接配置缺失,无法启动")
    fmt.Println("2. 这行代码不会被执行")
}

运行结果如下。

1. 程序开始启动
(报错)panic: 数据库连接配置缺失,无法启动

分析:

程序从上往下执行,先打印出 "1. 程序开始启动"。紧接着遇到 panic("数据库连接配置缺失,无法启动"),程序立即中断并在控制台输出报错信息及出错行号堆栈,排在 panic 下面的第 2 条打印语句永远不会执行。

虽然 panic 会跳过后面的普通代码,但如果我们在 panic 发生之前登记过 defer 语句,这些 defer 语句依然会在函数退出前正常执行。我们再来看一个示例。

示例 2:panic 前已登记的 defer

package main

import "fmt"

func main() {
    defer fmt.Println("defer 1:清理临时资源")
    defer fmt.Println("defer 2:关闭已打开的文件")

    fmt.Println("程序正在运行...")
    panic("发生严重异常")

    defer fmt.Println("defer 3:这句不会执行")
}

运行结果如下。

程序正在运行...
defer 2:关闭已打开的文件
defer 1:清理临时资源
(报错)panic: 发生严重异常

分析:

从输出结果可以看出,当 panic("发生严重异常") 触发时,程序并没有立刻退出。它会先按照 “后进先出” 的顺序执行前面登记好的 defer 2 和 defer 1,最后才打印 panic 报错信息并退出。

至于写在 panic 下方的 defer 3,因为代码根本没有执行到那一行,自然也就没有机会登记和运行。

注意: 因为只有排在 panic 前面的 defer 语句才会在崩溃前执行,所以在编写用于释放资源或拦截异常的 defer 语句时,我们都应该把它写在函数体的最开头。

使用 recover() 捕获异常

对于需要 24 小时不间断运行的后台程序(如网站服务器),如果某一个用户的请求触发了 panic,我们肯定不希望整个服务器直接停机退出。这时,我们就可以在 defer 延迟调用的匿名函数里,使用内置的 recover() 函数来拦截 panic。

语法:

defer func() {
    if err := recover(); err != nil {
        // 拦截异常后的处理代码
    }
}()

说明:

recover() 函数没有参数。当函数执行过程中发生 panic 时,defer 匿名函数里的 recover() 会捕获到这次异常,并返回当时传给 panic() 的错误信息。

紧接着,recover() 会中止崩溃流程,让外层调用方恢复正常执行。如果函数执行期间没有发生 panic,调用 recover() 只会返回 nil。

如果拿开车来打比方,普通的 error 就像导航提示 “前方拥堵”,我们换条路走就行。panic 则像高速行驶时突然爆胎,车子没法继续往前开了。此时 defer 配合 recover() 就像是车上的 “安全气囊”,能在发生意外时及时缓冲,保住主程序不至于彻底崩溃。

error 与 panic 异常拦截机制对比

示例 3:跨函数拦截切片越界 panic

package main

import "fmt"

// 内层子函数:直接按索引读取,越界时会触发 panic
func getScore(scores []int, index int) int {
    return scores[index]
}

// 外层函数:在开头登记 defer 拦截下层抛出的 panic
func safeGetScore(scores []int, index int) {
    defer func() {
        if err := recover(); err != nil {
            fmt.Printf("已拦截异常:%v\n", err)
        }
    }()

    val := getScore(scores, index)
    fmt.Printf("第 %d 个成绩:%d\n", index+1, val)
}

func main() {
    scores := []int{88, 92, 95}
    safeGetScore(scores, 5)
    safeGetScore(scores, 1)
    fmt.Println("main 函数正常结束")
}

运行结果如下。

已拦截异常:runtime error: index out of range [5] with length 3
第 2 个成绩:92
main 函数正常结束

分析:

在这个例子中,panic 发生在内层子函数 getScore() 里,而 recover() 写在外层的 safeGetScore() 中,程序会沿着调用链向上拦截:

  • 第 1 次调用:传入越界下标 5 后,内层 getScore() 访问 scores[5] 触发 index out of range(下标越界)运行时 panic。程序随即向上回退到 safeGetScore(),跳过后面的打印语句,由开头的 defer 匿名函数调用 recover() 拦住异常。
  • 第 2 次调用:由于上一次崩溃已被成功拦截,main() 函数不会中断,继续往下调用 safeGetScore(scores, 1)。这次下标合法,正常读取并输出成绩 92,退出时 recover() 返回 nil,不会打印异常提示。

在使用 recover() 时,小伙伴们一定要记住:recover() 必须放在 defer 后面的匿名函数内部调用才有效。下面这两种错误写法都无法拦截异常。

// 正确方式
defer func() {
    if err := recover(); err != nil {
        fmt.Println(err)
    }
}()

// 错误方式 1
recover()

// 错误方式 2
defer recover()

无论是脱离 defer 直接写一行 recover(),还是省掉外层匿名函数直接写 defer recover(),都拦不住 panic,程序遇到异常照样会崩溃退出。

在编写底层工具函数时,有时我们通过 recover() 拦住异常后,还需要配合前面学过的具名返回值,把捕获到的异常转化为一个普通的 error 传回给调用方。

示例 4:将 panic 转化为 error 返回

package main

import "fmt"

// 声明具名返回值 val 和 err
func safeRead(scores []int, index int) (val int, err error) {
    defer func() {
        if r := recover(); r != nil {
            err = fmt.Errorf("读取元素失败: %v", r)
        }
    }()

    return scores[index], nil
}

func main() {
    scores := []int{88, 92, 95}
    val, err := safeRead(scores, 5)
    if err != nil {
        fmt.Printf("调用失败:%v\n", err)
    } else {
        fmt.Printf("调用成功:%d\n", val)
    }
}

运行结果如下。

调用失败:读取元素失败: runtime error: index out of range [5] with length 3

分析:

在 safeRead() 函数中,如果我们传入合法下标 1,执行 return scores[1], nil 会正常把 92 和 nil 赋给返回值 val 和 err。

而在上面的 safeRead(scores, 5) 中,访问 scores[5] 立即触发了越界 panic,还没走到正常返回赋值那一步就直接中断跳去执行 defer 了。

由于 defer 匿名函数没法替外层函数重新 return,所以我们提前把返回值声明为具名形式 (val int, err error)。这样 recover() 拦住崩溃后,就能直接修改具名变量 err,把转化后的普通 error 传回 main()。

如何选择 error 与 panic?

学完了 error 和 panic 之后,很多小伙伴在自己写函数时会拿不准什么时候用哪一个。在实际项目中,我们只需要遵循以下 2 条选型原则就可以了:

  • 常规业务问题一律返回 error:像用户输入参数不合法、查询不到记录、文件不存在或网络请求超时,都属于完全可预见的常规情况。编写普通业务函数时,我们应该返回 error 交由调用方使用 if err != nil 处理,千万不要动不动就调用 panic()。
  • 仅在程序无法继续运行时使用 panic:如果程序刚启动做初始化检查,发现必需的配置文件缺失、关键端口被占用或数据库连不上,继续运行已经没有意义。只有这种时候,才适合主动调用 panic() 让程序停下来排查。

简单来说,日常开发以返回 error 为主,以 panic 和 recover() 为辅。

常见问题

1. 为什么直接写一行 recover() 或 defer recover() 都无法拦截异常?

这和代码的执行时机直接相关。如果不加 defer,把 recover() 当普通代码写在 panic() 前面时,异常还没发生,只能返回 nil。如果写在 panic() 后面,程序在触发异常那一刻就已经中断跳出了,根本走不到那一行。

而直接写 defer recover() 省掉了外层匿名函数,不满足 Go 语言必须在延迟函数内部直接调用 recover() 的语法规则,同样不会生效。因此,我们必须把 recover() 包在 defer func() { ... }() 匿名函数内部调用。

2. 发生 panic 并被 recover() 拦截后,当前函数里 panic 下面的代码还会继续运行吗?

不会。在某个函数内部一旦触发 panic,该函数里排在 panic 下面的代码就已经被彻底跳过了。recover() 所说的 “恢复正常执行”,并不是回到触发异常的那一行接着往下跑,而是结束当前出错的函数并返回到上层调用方(如 main()),让上层调用方继续往下运行。

同时还要留意,recover() 只能拦截当前函数调用链中发生的 panic。后面学习并发编程开启多个独立任务时,每个独立任务都需要各自配置 recover(),不能仅靠 main() 函数里的 recover() 去跨任务拦截。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号