Golang面试中经常会遇到defer-panic-recover相关的题目，其底层工作原理是什么呢？

快速要点：

• 调用panic(xxx)内置方法或运行时错误会触发程序崩溃exit code=2退出
• 错误处理流程：panic后函数的正常执行流程将立即中止，但注册的defer-func将被倒序执行，并返回到调用函数，就像调用函数触发了panic一样继续上报，直至所属goroutine所有调用链方法中止，最终由fatalpanic打印错误并退出
• panic关键字在编译阶段会被替换成runtime.gopanic()方法
• defer调用会在编译阶段替换成对 deferproc的调用，同时在包装方法返回前插入deferreturn方法
• defer调用时维护了runtime._defer结构（插入到g._defer的最前面），通过link字段维护了个链表，先进后出调用
• gopanic()处理逻辑大致是：从current-g获取defer链表，并依次执行
• recover调用编译阶段会替换成gorecover调用
• 在panic-defer处理链上如有recover调用，则会设置defer.recovered=true，并继续运行defer链方法
• recover()只在defer-func中调用有效，否则返回nil。原理大致是 argp == uintptr(p.argp) ，要求recover时的栈指针和panic的栈指针要匹配，根据源码中的todo将来可能会改变这一要求

// builtin.go#234
// The recover built-in function allows a program to manage behavior of a
// panicking goroutine. Executing a call to recover inside a deferred
// function (but not any function called by it) stops the panicking sequence
// by restoring normal execution and retrieves the error value passed to the
// call of panic. If recover is called outside the deferred function it will
// not stop a panicking sequence. In this case, or when the goroutine is not
// panicking, or if the argument supplied to panic was nil, recover returns
// nil. Thus the return value from recover reports whether the goroutine is
// panicking.
func recover() interface{}

// runtime/panic.go#1043, p is a panic
      p.argp = unsafe.Pointer(getargp())

			if goexperiment.RegabiDefer {
				fn := deferFunc(d)
				fn()
			} else {
				// Pass a dummy RegArgs since we'll only take this path if
				// we're not using the register ABI.
				var regs abi.RegArgs
				reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz), uint32(d.siz), &regs)
			}
		}

// runtime/panic.go#1159
// The implementation of the predeclared function recover.
// Cannot split the stack because it needs to reliably
// find the stack segment of its caller.
//
// TODO(rsc): Once we commit to CopyStackAlways,
// this doesn't need to be nosplit.
//go:nosplit
func gorecover(argp uintptr) interface{} {
   // Must be in a function running as part of a deferred call during the panic.
   // Must be called from the topmost function of the call
   // (the function used in the defer statement).
   // p.argp is the argument pointer of that topmost deferred function call.
   // Compare against argp reported by caller.
   // If they match, the caller is the one who can recover.
   gp := getg()
   p := gp._panic
   if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
      p.recovered = true
      return p.arg
   }
   return nil
}