概述

panic 能够改变程序的控制流，函数调用panic时会立刻停止执行函数的其他代码，并在执行结束后在当前Goroutine中递归执行调用方的延迟函数调用defer；

  • recover可以中止panic造成的程序崩溃。它是一个只能在defer中发挥作用的函数，在其他作用域中调用不会发挥任何作用；

当前执行的goroutine中、有一个defer链表的头指针、其实也有一个panic链表头指针。panic链表链起来的是一个一个_panic结构体，和defer链表一样。发生新的panic时，也是在链表头上插入新的_panic结构体，所以链表头上的panic就是当前正在执行的那一个。

现象

  • panic 只会触发当前 Goroutine 的延迟defer函数调用；
  • recover 只有在 defer 函数中调用才会生效；
  • panic 允许在 defer 中嵌套多次调用；

跨协程失效

  1. func main() {
  2.     defer println("in main")
  3.     go func() {
  4.         defer println("in goroutine")
  5.         panic("")
  6.     }()
  8.     time.Sleep(1 * time.Second)
  9. }
  11. $ go run main.go
  12. in goroutine
  13. panic:
  14. ...

defer 关键字对应的runtime.deferproc会将延迟调用函数与调用方所在 Goroutine 进行关联。所以当程序发生崩溃时只会调用当前 Goroutine 的延迟调用函数也是非常合理的。

失效的崩溃恢复

  1. func main() {
  2.     defer fmt.Println("in main")
  3.     if err := recover(); err != nil {
  4.         fmt.Println(err)
  5.     }
  7.     panic("unknown err")
  8. }
  10. $ go run main.go
  11. in main
  12. panic: unknown err
  14. goroutine 1 [running]:
  15. main.main()
  16.     ...
  17. exit status 2

panic 关键字在 Go 语言的源代码是由数据结构 runtime._panic 表示的。每当我们调用 panic 都会创建一个如下所示的数据结构存储相关信息：

  1. type _panic struct {
  2.     argp      unsafe.Pointer
  3.     arg       interface{}
  4.     link      *_panic
  5.     recovered bool
  6.     aborted   bool
  8.     pc        uintptr
  9.     sp        unsafe.Pointer
  10.     goexit    bool
  11. }
  1. argp 是指向 defer 调用时参数的指针；
  2. arg 是调用 panic 时传入的参数；
  3. link 指向了更早调用的 runtime._panic 结构；
  4. recovered 表示当前 runtime._panic 是否被 recover 恢复；
  5. aborted 表示当前的 panic 是否被强行终止；

程序崩溃

panic 函数是如何终止程序的。编译器会将关键字 panic 转换成 runtime.gopanic，该函数的执行过程包含以下几个步骤：

  1. 创建新的 runtime._panic 结构并添加到所在 Goroutine _panic 链表的最前面；
  2. 在循环中不断从当前 Goroutine 的 _defer 中链表获取 runtime._defer 并调用 runtime.reflectcall 运行延迟调用函数；
  3. 调用 runtime.fatalpanic 中止整个程序；
  1. func gopanic(e interface{}) {
  2.     gp := getg()
  3.     ...
  4.     var p _panic
  5.     p.arg = e
  6.     p.link = gp._panic
  7.     gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
  9.     for {
  10.         d := gp._defer
  11.         if d == nil {
  12.             break
  13.         }
  15.         d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
  17.         reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
  19.         d._panic = nil
  20.         d.fn = nil
  21.         gp._defer = d.link
  23.         freedefer(d)
  24.         if p.recovered {
  25.             ...
  26.         }
  27.     }
  29.     fatalpanic(gp._panic)
  30.     *(*int)(nil) = 0
  31. }

panic 内部主要流程是这样：

  • 获取当前调用者所在的 g ，也就是 goroutine
  • 遍历并执行 g 中的 defer 函数
  • 如果 defer 函数中有调用 recover ，并发现已经发生了 panic ，则将 panic 标记为 recovered
  • 在遍历 defer 的过程中，如果发现已经被标记为 recovered ，则提取出该 defer 的 sp 与 pc，保存在 g 的两个状态码字段中。
  • 调用 runtime.mcall 切到 m->g0 并跳转到 recovery 函数，将前面获取的 g 作为参数传给 recovery 函数。runtime.mcall 的代码在 go 源码的 src/runtime/asm_xxx.s 中，xxx 是平台类型，如 amd64 。

哪些情况会出现panic

1. 数组越界

  1. func f() {
  2.     defer func() {
  3.         if err := recover(); err != nil {
  4.             fmt.Println(err)
  5.         }
  6.     }()
  7.     var bar = []int{1}
  8.     fmt.Println(bar[1])
  9. }
  11. func main() {
  12.     f()
  13.     fmt.Println("exit")
  14. }

2. 访问未初始化的指针或 nil 指针

  1. import (
  2.     "fmt"
  3. )
  5. func foo(){
  6.     defer func(){
  7.         if err := recover(); err != nil {
  8.             fmt.Println(err)
  9.         }
  10.     }()
  11.     var b *int
  12.     fmt.Println(*b)
  13. }
  15. func main(){
  16.     foo()
  17.     fmt.Println("exit")
  18. }

3. 试图往已经 close 的 chan 里发送数据

  1. func foo() {
  2.     defer func() {
  3.         if err := recover(); err != nil {
  4.             fmt.Println(err)
  5.         }
  6.     }()
  7.     var bar = make(chan int, 1)
  8.     close(bar)
  9.     bar <- 1
  10. }
  12. func main() {
  13.     foo()
  14.     fmt.Println("exit")
  15. }

并发读写相同 map
  1. package main
  3. import "fmt"
  5. func foo() {
  6.     defer func() {
  7.         if err := recover(); err != nil {
  8.             fmt.Println(err)
  9.         }
  10.     }()
  11.     var bar = make(map[int]int)
  12.     go func() {
  13.         defer func() {
  14.             if err := recover(); err != nil {
  15.                 fmt.Println(err)
  16.             }
  17.         }()
  18.         for {
  19.             bar[1] = 1
  20.         }
  21.     }()
  22.     for {
  23.         bar[1] = 1
  24.     }
  25. }
  27. func main() {
  28.     foo()
  29.     fmt.Println("exit")
  30. }

对于并发读写 map 的地方，应该对 map 加锁

4. 类型断言

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func foo(){
  8.     defer func(){
  9.         if err := recover(); err != nil {
  10.             fmt.Println(err)
  11.         }
  12.     }()
  13.     var i interface{} = "abc"
  14.     _ = i.([]string)
  15. }
  17. func main(){
  18.     foo()
  19.     fmt.Println("exit")
  20. }

recover是怎么实现的

  1. func gorecover(argp uintptr) interface{} {
  2.     // Must be in a function running as part of a deferred call during the panic.
  3.     // Must be called from the topmost function of the call
  4.     // (the function used in the defer statement).
  5.     // p.argp is the argument pointer of that topmost deferred function call.
  6.     // Compare against argp reported by caller.
  7.     // If they match, the caller is the one who can recover.
  8.     gp := getg()
  9.     p := gp._panic
  10.     if p != nil && !p.recovered && argp == uintptr(p.argp) {
  11.         p.recovered = true
  12.         return p.arg
  13.     }
  14.     return nil
  15. }

recover会先检查gp(current goroutine)是否在panic流程中，如果不是，直接返回nil。所以在普通流程调用recover除了耗费cpu并不会有什么实际作用。

如果确实当前goroutine在panic中，会设置recovered为true；panic流程中在调用完每个defer以后会检查recovered标记，如果为true则会退出panic流程，恢复正常。

recover函数只是设置了recovered标记，那么gouroutine是怎么从panic返回的呢？

从gopanic函数来看，reflectcall调用完recover之后，会在pc、sp中记录当前defer的pc、sp，然后调用recovery；

  1. func gopanic(e interface{}) {
  2.     gp := getg()
  3.     if gp.m.curg != gp {
  4.         print("panic: ")
  5.         printany(e)
  6.         print("\n")
  7.         throw("panic on system stack")
  8.     }
  10.     if gp.m.mallocing != 0 {
  11.         print("panic: ")
  12.         printany(e)
  13.         print("\n")
  14.         throw("panic during malloc")
  15.     }
  16.     if gp.m.preemptoff != "" {
  17.         print("panic: ")
  18.         printany(e)
  19.         print("\n")
  20.         print("preempt off reason: ")
  21.         print(gp.m.preemptoff)
  22.         print("\n")
  23.         throw("panic during preemptoff")
  24.     }
  25.     if gp.m.locks != 0 {
  26.         print("panic: ")
  27.         printany(e)
  28.         print("\n")
  29.         throw("panic holding locks")
  30.     }
  32.     var p _panic
  33.     p.arg = e
  34.     p.link = gp._panic
  35.     gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
  37.     atomic.Xadd(&runningPanicDefers, 1)
  39.     // By calculating getcallerpc/getcallersp here, we avoid scanning the
  40.     // gopanic frame (stack scanning is slow...)
  41.     addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))
  43.     for {
  44.         d := gp._defer
  45.         if d == nil {
  46.             break
  47.         }
  49.         // If defer was started by earlier panic or Goexit (and, since we're back here, that triggered a new panic),
  50.         // take defer off list. An earlier panic will not continue running, but we will make sure below that an
  51.         // earlier Goexit does continue running.
  52.         // 如果触发 defer 的 panic 是在前一个 panic 或者 Goexit 的 defer 中触发的，那么将前一个 defer 从列表中去除。前一个 panic 或者 Goexit 将不再继续执行。
  54.         if d.started {
  55.             if d._panic != nil {
  56.                 d._panic.aborted = true
  57.             }
  58.             d._panic = nil
  59.             if !d.openDefer {
  60.                 // For open-coded defers, we need to process the
  61.                 // defer again, in case there are any other defers
  62.                 // to call in the frame (not including the defer
  63.                 // call that caused the panic).
  64.                 d.fn = nil
  65.                 gp._defer = d.link
  66.                 freedefer(d)
  67.                 continue
  68.             }
  69.         }
  71.         // Mark defer as started, but keep on list, so that traceback
  72.         // can find and update the defer's argument frame if stack growth
  73.         // or a garbage collection happens before reflectcall starts executing d.fn.
  74.         d.started = true
  76.         // Record the panic that is running the defer.
  77.         // If there is a new panic during the deferred call, that panic
  78.         // will find d in the list and will mark d._panic (this panic) aborted.
  79.         d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
  81.         // 将 defer 标记为 started，但是保留在列表上，这样，如果在 reflectcall 开始执行 d.fn 之前发生了堆栈增长或垃圾回收，则 traceback 可以找到并更新 defer 的参数帧。
  82.         done := true
  83.         if d.openDefer {
  84.             done = runOpenDeferFrame(gp, d)
  85.             if done && !d._panic.recovered {
  86.                 addOneOpenDeferFrame(gp, 0, nil)
  87.             }
  88.         } else {
  89.             p.argp = unsafe.Pointer(getargp(0))
  90.             reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
  91.         }
  92.         p.argp = nil
  94.         // reflectcall did not panic. Remove d.
  95.         if gp._defer != d {
  96.             throw("bad defer entry in panic")
  97.         }
  98.         d._panic = nil
  100.         // trigger shrinkage to test stack copy. See stack_test.go:TestStackPanic
  101.         //GC()
  103.         pc := d.pc
  104.         sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
  105.         if done {
  106.             d.fn = nil
  107.             gp._defer = d.link
  108.             freedefer(d)
  109.         }
  110.         if p.recovered {
  111.             gp._panic = p.link
  112.             if gp._panic != nil && gp._panic.goexit && gp._panic.aborted {
  113.                 // A normal recover would bypass/abort the Goexit.  Instead,
  114.                 // we return to the processing loop of the Goexit.
  115.                 gp.sigcode0 = uintptr(gp._panic.sp)
  116.                 gp.sigcode1 = uintptr(gp._panic.pc)
  117.                 mcall(recovery)
  118.                 throw("bypassed recovery failed") // mcall should not return
  119.             }
  120.             atomic.Xadd(&runningPanicDefers, -1)
  122.             if done {
  123.                 // Remove any remaining non-started, open-coded
  124.                 // defer entries after a recover, since the
  125.                 // corresponding defers will be executed normally
  126.                 // (inline). Any such entry will become stale once
  127.                 // we run the corresponding defers inline and exit
  128.                 // the associated stack frame.
  129.                 d := gp._defer
  130.                 var prev *_defer
  131.                 for d != nil {
  132.                     if d.openDefer {
  133.                         if d.started {
  134.                             // This defer is started but we
  135.                             // are in the middle of a
  136.                             // defer-panic-recover inside of
  137.                             // it, so don't remove it or any
  138.                             // further defer entries
  139.                             break
  140.                         }
  141.                         if prev == nil {
  142.                             gp._defer = d.link
  143.                         } else {
  144.                             prev.link = d.link
  145.                         }
  146.                         newd := d.link
  147.                         freedefer(d)
  148.                         d = newd
  149.                     } else {
  150.                         prev = d
  151.                         d = d.link
  152.                     }
  153.                 }
  154.             }
  156.             gp._panic = p.link
  157.             // Aborted panics are marked but remain on the g.panic list.
  158.             // Remove them from the list.
  159.             for gp._panic != nil && gp._panic.aborted {
  160.                 gp._panic = gp._panic.link
  161.             }
  162.             if gp._panic == nil { // must be done with signal
  163.                 gp.sig = 0
  164.             }
  165.             // Pass information about recovering frame to recovery.
  166.             gp.sigcode0 = uintptr(sp)
  167.             gp.sigcode1 = pc
  168.             mcall(recovery)
  169.             throw("recovery failed") // mcall should not return
  170.         }
  171.     }
  173.     // ran out of deferred calls - old-school panic now
  174.     // Because it is unsafe to call arbitrary user code after freezing
  175.     // the world, we call preprintpanics to invoke all necessary Error
  176.     // and String methods to prepare the panic strings before startpanic.
  177.     preprintpanics(gp._panic)
  179.     fatalpanic(gp._panic) // should not return
  180.     *(*int)(nil) = 0      // not reached
  181. }

在recovery中，设置当前goroutine的sched的sp/pc等，调用gogo切到defer的上下文去。

  1. // Unwind the stack after a deferred function calls recover
  2. // after a panic. Then arrange to continue running as though
  3. // the caller of the deferred function returned normally.
  4. // 在 panic 后，在延迟函数中调用 recover 的时候，将回溯堆栈，并且继续执行，就像延迟函数的调用者正常返回一样。
  6. func recovery(gp *g) {
  7.     // Info about defer passed in G struct.
  8.     sp := gp.sigcode0
  9.     pc := gp.sigcode1
  11.     // d's arguments need to be in the stack.
  12.     if sp != 0 && (sp < gp.stack.lo || gp.stack.hi < sp) {
  13.         print("recover: ", hex(sp), " not in [", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
  14.         throw("bad recovery")
  15.     }
  17.     // Make the deferproc for this d return again,
  18.     // this time returning 1. The calling function will
  19.     // jump to the standard return epilogue.
  20.     // 让延迟函数的 deferproc 再次返回，这次返回 1 。调用函数将跳转到标准返回结尾。
  21.     gp.sched.sp = sp
  22.     gp.sched.pc = pc
  23.     gp.sched.lr = 0
  24.     gp.sched.ret = 1
  25.     gogo(&gp.sched)
  26. }

为啥从defer上取的sp/pc能回到defer的返回流程上来？来看看defer

defer

defer是一个面向编译器的声明，他会让编译器做两件事：

  1. 编译器会将defer声明编译为runtime.deferproc(fn)，这样运行时，会调用runtime.deferproc，在deferproc中将所有defer挂到goroutine的defer链上；
  2. 编译器会在函数return之前（注意，是return之前，而不是return xxx之前，后者不是一条原子指令），增加runtime.deferreturn调用；这样运行时，开始处理前面挂在defer链上的所有defer。

deferreturn

先判断链表有没有defer，然后jmpdefer去做defer声明的事情，但jmpdefer魔幻的地方是它会跳回到deferreturn之前，也就是说，会再次deferreturn一下，如果defer链表还有没处理的defer，那么会再这么循环一把，如果空了，那就return，defer处理结束。

recovery是如何从panic切回到normal流程的。

注意

  1. 1.利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。
  2. 2.recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。
  3. 3.多个 defer 会形成 defer 栈，后定义的 defer 语句会被最先调用。


  1. func recovery(gp *g) {
  2.     // Info about defer passed in G struct.
  3.     sp := gp.sigcode0
  4.     pc := gp.sigcode1
  6.     // d's arguments need to be in the stack.
  7.     if sp != 0 && (sp < gp.stack.lo || gp.stack.hi < sp) {
  8.         print("recover: ", hex(sp), " not in [", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
  9.         throw("bad recovery")
  10.     }
  12.     // Make the deferproc for this d return again,
  13.     // this time returning 1. The calling function will
  14.     // jump to the standard return epilogue.
  15.     // 让延迟函数的 deferproc 再次返回，这次返回 1 。调用函数将跳转到标准返回结尾。
  16.     gp.sched.sp = sp
  17.     gp.sched.pc = pc
  18.     gp.sched.lr = 0
  19.     gp.sched.ret = 1
  20.     gogo(&gp.sched)
  21. }

recovery将调用recover函数的defer的pc和sp设置到了当前goroutine的sched上，并且将ret设置为1，然后gogo重新调度。

前面代码可以看到，defer的pc和sp是deferproc下面的代码，也就是下一个defer或者normal处理流程。但这样设置，gogo重新调度不就又回到函数开始的地方了吗？

原来，编译器为defer声明生成的代码，总是会在deferproc后面检查其返回值，如果返回值为0，那么deferproc成功，可以继续处理下一个defer声明或者后面的代码；如果返回值不为0，那么会跳到当前函数的最后，return之前。

也就是说，gogo调度之后，相当于调用了deferproc；由于返回值为1，检查失败，直奔return之前的deferreturn，因此，可以再次进入defer流程。

由于调用recover的defer已经从defer链表上摘掉了，所以可以继续执行之前没完成的defer，并最终返回当前函数的调用者。

panic是怎么退出的

panic退出时会打印调用栈，最终调用exit(-2)退出整个进程。

注意

recover只在defer的函数中有效，如果不是在refer上下文中调用，recover会直接返回nil。

参考

Golang: 深入理解panic and recover
Effective Go
面向信仰编程