考察defer和panic执行顺序的问题

题目来源: 小米

答案：

例子

  1. func main(){
  2.     call()
  3.     fmt.Println("333 Helloworld")
  4. }
  6. func call()  {
  8.     defer func(){
  9.         fmt.Println("11111")
  10.     }()
  11.     defer func(){
  12.         fmt.Println("22222")
  13.     }()
  14.     defer func() {
  15.         if r := recover(); r!= nil {
  16.             fmt.Println("Recover from r : ",r)
  17.         }
  18.     }()
  19.     defer func(){
  20.         fmt.Println("33333")
  21.     }()
  23.     fmt.Println("111 Helloworld")
  24.     panic("Panic 1!")
  25.     // 这个panic和后面的代码已经不会执行，ide应该会有提示
  26.     panic("Panic 2!")
  27.     fmt.Println("222 Helloworld")
  28. }
  30. // output
  31. 111 Helloworld
  32. 33333
  33. Recover from r :  Panic 1!
  34. 22222
  35. 11111
  36. 333 Helloworld

源码实现

  1. // panic 关键字代码实现. 
  2. func gopanic(e interface{}) {
  3.     gp := getg()    // getg()返回当前协程的 g 结构体指针，g 结构体描述 goroutine
  4.     if gp.m.curg != gp {
  5.         print("panic: ")
  6.         printany(e)
  7.         print("\n")
  8.         throw("panic on system stack")
  9.     }
  11.     //  省略无用代码. 
  12.     var p _panic
  13.     p.arg = e
  14.     p.link = gp._panic
  15.     gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
  17.     atomic.Xadd(&runningPanicDefers, 1)
  19.     for {
  21.         // 获取当前协程的defer链表.
  22.         // 这里defer链表和在代码定义的顺序是相反的，类似于先进后出的概念. 
  23.         d := gp._defer    
  24.         if d == nil {
  25.             break    // 当前协程的defer都被执行后，defer链表为空，此时退出for循环
  26.         }
  28.         // If defer was started by earlier panic or Goexit (and, since we're back here, that triggered a new panic),
  29.         // take defer off list. The earlier panic or Goexit will not continue running.
  30.         if d.started {    // 发生panic后，在defer中又遇到panic(),则会进入这个代码块
  31.             if d._panic != nil {
  32.                 d._panic.aborted = true
  33.             }
  34.             d._panic = nil
  35.             d.fn = nil
  36.             gp._defer = d.link
  37.             freedefer(d)  // defer 已经被执行过，则释放这个defer，继续for循环。
  38.             continue
  39.         }
  41.         // Mark defer as started, but keep on list, so that traceback
  42.         // can find and update the defer's argument frame if stack growth
  43.         // or a garbage collection happens before reflectcall starts executing d.fn.
  44.         d.started = true
  46.         // Record the panic that is running the defer.
  47.         // If there is a new panic during the deferred call, that panic
  48.         // will find d in the list and will mark d._panic (this panic) aborted.
  49.         d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
  51.         p.argp = unsafe.Pointer(getargp(0))
  52.         reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))   // 执行当前协程defer链表头的defer
  53.         p.argp = nil
  55.         // reflectcall did not panic. Remove d.
  56.         if gp._defer != d {
  57.             throw("bad defer entry in panic")
  58.         }
  59.         d._panic = nil
  60.         d.fn = nil
  61.         gp._defer = d.link  // 从defer链中移除刚刚执行过的defer
  63.         // trigger shrinkage to test stack copy. See stack_test.go:TestStackPanic
  64.         //GC()
  66.         pc := d.pc
  67.         sp := unsafe.Pointer(d.sp) // must be pointer so it gets adjusted during stack copy
  68.         freedefer(d)   // 释放刚刚执行过的defer
  69.         if p.recovered {    // defer()中遇到recover后进入这个代码块
  70.             atomic.Xadd(&runningPanicDefers, -1)
  72.             gp._panic = p.link
  73.             mcall(recovery)   // 跳转到recover()处，继续往下执行
  74.             throw("recovery failed") // mcall should not return
  75.         }
  76.     }
  78.     // ran out of deferred calls - old-school panic now
  79.     // Because it is unsafe to call arbitrary user code after freezing
  80.     // the world, we call preprintpanics to invoke all necessary Error
  81.     // and String methods to prepare the panic strings before startpanic.
  82.     preprintpanics(gp._panic)
  83.     startpanic()
  85.     // startpanic set panicking, which will block main from exiting,
  86.     // so now OK to decrement runningPanicDefers.
  87.     atomic.Xadd(&runningPanicDefers, -1)
  88.     printpanics(gp._panic)   // 输出panic信息
  89.     dopanic(0)       // should not return
  90.     *(*int)(nil) = 0 // not reached
  91. }

概括

大概的流程就是，如果遇见panic关键字的话，那么go执行器就会进入代码gopanic函数中，进入之后会拿到表示当前协程g的指针，然后通过该指针拿到当前协程的defer链表，通过for循环来进行执行defer，如果在defer中又遇见了panic的话，则会释放这个defer，通过continue去执行下一个defer，然后就是一个一个的执行defer了，如果在defer中遇见recover，那么将会通过mcall(recovery)去执行panic.

参考资料

https://juejin.cn/post/6974298479065563166