介绍

在golang的设计思想中，panic是用于在已知的错误发生时中断程序运行，比如空指针，数组越界等，在golang的创始人眼中，这些错误都是不被允许的，因此只要发生，就需要中断程序运行，然而在实际的应用中，我们并不总是希望panic的出现使服务崩溃，因此golang提供了recover函数，可以用于捕捉panic，将其转换为一般的错误进行处理。本文主要介绍panic与recover 之间的关系。

在了解panic与recover之前，需要先了解golang的defer机制，可以参考前一篇文章 了解defer

Panic函数

Panic函数的实现：runtime/panic.go gopanic函数

panic对应结构体

1
2
3
4
5
6
7
8
9
10

type _panic struct {
   argp      unsafe.Pointer // 对应defer函数相关变量的指针
   arg       interface{}    // argument to panic  panic("xxx")，指向"xxx"的指针
   link      *_panic        // link to earlier panic   panic会被不断包装，指向上一层panic
   pc        uintptr        // where to return to in runtime if this panic is bypassed
   sp        unsafe.Pointer // where to return to in runtime if this panic is bypassed
   recovered bool           // whether this panic is over
   aborted   bool           // the panic was aborted
   goexit    bool
}

panic内部实现流程

用文字描述panic的处理流程：

1. 获取当前panic所在的goroutine标识，拿到goroutine结构体 gp
2. 生成一个panic结构体 p，将 gp.panic指向p
3. 遍历当前goroutine已注册的defer函数集合，获取集合中的第一个defer
4. 如果没有defer函数，结束循环，打印 gp.panic
5. 如果有defer函数 d，判断此defer函数是否执行过
   • 如果已经执行过
     1. 判断 defer结构体 d的 panic变量是否为空，不为空，则设置 此panic需要强制退出
     2. 设置 d.panic=nil；如果defer函数并不是 open-coded defer，设置 d.fn=nil （d.fn就是defer对应的执行函数）; 将 defer函数的下一个defer函数 设置给 gp.defer，释放这个defer函数，结束此次循环
   • 如果没有执行过
     1. 设置 d.started=true，标识 这个defer函数已经执行了
     2. 将 d.panic指向 前面生成的 panic结构体 p
     3. 如果 不是 open-coded defer，则执行 defer对应的函数；（将defer结构体对应的变量全部传入了，包括panic指针），将 p的 argp设置为 defer结构体的对应变量地址
     4. 设置 d.panic=nil; 设置defer.fn = nil; 将 defer函数的下一个defer函数 设置给 gp.defer，释放这个defer函数
     5. 如果panic p已经被recover了，则将panic链条上的全部recover
     6. 结束此次循环
6. 循环结束后，处理gp.panic

recover函数

recover函数的实现： runtime/panic.go gorecover()

1
2
3
4
5
6
7
8
9
10
11

func gorecover(argp uintptr) interface{} {
   gp := getg()  //获取当前goroutine
   p := gp._panic  //获取goroutine中的panic
   
   //panic不为空，panic当前不需要终止goroutine， panic中的defer函数参数地址与本次调用recover的函数参数地址相同
   if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
      p.recovered = true
      return p.arg
   }
   return nil
}

gorecover(argp uintptr)中的 argp是调用recover函数的参数地址，通常是defer函数的参数地址

常见问题

1、嵌套的defer中无法recover panic

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
   defer func() {
      fmt.Println("第一个defer开始")
      defer func() {
         fmt.Println("第二个defer开始")
         if e := recover(); e != nil {
            fmt.Println("第二个defer panic捕获")
         }
         fmt.Println("第二个defer结束")
      }()
      fmt.Println("第一个defer结束")
   }()
   panic("测试")
}

原因
根据前面 panic的实现流程，panic会生成一个变量p，设置p.argp为第一个defer相关的参数地址指针；而执行defer时，gorecover()方法中的参数 argp时第二个defer相关的参数地址指针，因此无法满足条件，无法recover；

2、recover函数包装后无法生效

1
2
3
4
5
6
7
8
9
10
11
12
13
14

func main() {
   defer func() {
      RecoverPanic()
   }()
   panic("测试")
}

func RecoverPanic() {
   if e := recover(); e != nil {
      fmt.Println("RecoverPanic 捕捉到了panic")
      fmt.Println("panic panic panic: ", e)
   }
   fmt.Println("RecoverPanic 执行了")
}

原因
根据前面 panic的实现流程，panic会生成一个变量p，设置p.argp为第一个defer相关的属性变量指针；
而执行recover时，gorecover()方法中的参数 argp时RecoverPanic函数的参数地址，因此无法满足条件，无法recover；

赏

谢谢你请我吃糖果

支付宝

微信