golang panic关键词执行原理与代码分析

使用的go版本为 go1.21.2

首先我们写一个简单的panic调度与捕获代码

package main

func main() {
	defer func() {
		recover()
	}()

	panic("panic test")
}

通过go build -gcflags -S main.go获取到对应的汇编代码

可以看到当我们调度panic时，Go的编译器会将这段代码翻译为CALL runtime.gopanic(SB)

我们先来看一下panic构造体的底层源码

panic源码与解读

//代码位置 $GOROOT/src/runtime/runtime2.go L:1035

type _panic struct {
	argp      unsafe.Pointer // 指向在 panic 运行期间执行的延迟调用参数的指针，不可移动 - liblink 工具已知其位置
	arg       any            // 参数
	link      *_panic        // panic链表
	pc        uintptr        // 返回到运行时的位置
	sp        unsafe.Pointer // 返回到运行时的栈指针位置
	recovered bool           // 是否已被恢复
	aborted   bool           // 是否已被中止
	goexit    bool           // 是否执行了 Goexit 函数
}

gopanic源码与解读

//代码位置 $GOROOT/src/runtime/panic.go L:826
// 实现预声明函数 panic
func gopanic(e any) {
	// 处理异常参数为 nil 的情况
	if e == nil {
		// 如果 debug.panicnil 不等于 1，将e设置为PanicNilError类型
		//
		if debug.panicnil.Load() != 1 {
			e = new(PanicNilError)
		} else {
			panicnil.IncNonDefault()
		}
	}

	// 获取当前的G
	gp := getg()

	// 判断当前M上运行的G是不是当前G
	if gp.m.curg != gp {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic on system stack")
	}

	// malloc过程中出现panic
	if gp.m.mallocing != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic during malloc")
	}

	// 禁止抢占的情况下执行 panic (!="" 保持当前G在这M运行)
	if gp.m.preemptoff != "" {
		print("panic: ")
		printany(e)
		print("\n")
		print("preempt off reason: ")
		print(gp.m.preemptoff)
		print("\n")
		throw("panic during preemptoff")
	}

	//  当初M处于锁的状态
	if gp.m.locks != 0 {
		print("panic: ")
		printany(e)
		print("\n")
		throw("panic holding locks")
	}

	// 定义一个panic变量
	var p _panic
	p.arg = e //这个e 就是我们panic("xxxx") 里面写的东西

	//将这个panic加入到G的_panic链表中去
	p.link = gp._panic 
	gp._panic = (*_panic)(noescape(unsafe.Pointer(&p))) 

	// 增加运行panic延迟计数
	runningPanicDefers.Add(1)

	// 计算 getcallerpc/getcallersp，以避免扫描 gopanic 帧
	addOneOpenDeferFrame(gp, getcallerpc(), unsafe.Pointer(getcallersp()))

 
	for {
                //逐步获取当前G中的defer调用
		d := gp._defer
		// 如果获取到的构造体为空，直接返回。
		if d == nil {
			break
		}

		// 如果当前_defer运行，将_defer从G的延迟链表移除，释放对应的_defer构造体资源，防止重复执行
		if d.started {
			if d._panic != nil {
				d._panic.aborted = true
			}
			d._panic = nil
			if !d.openDefer {
				d.fn = nil
				gp._defer = d.link
				freedefer(d)
				continue
			}
		}

		// 标记当前_defer为运行状态
		d.started = true

		// 记录_defer的panic
		d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))

		done := true

		if d.openDefer { //如果_defer使用了 open-coded defers（编码的延迟调用）
			// 运行open-coded defer函数
			done = runOpenDeferFrame(d) //如果当前栈下面没有其他延迟函数，则返回true
			if done && !d._panic.recovered { //panic没有recover
				addOneOpenDeferFrame(gp, 0, nil)
			}
		} else {//执行对应方法
			//getargp返回其caller的保存callee参数的地址
			p.argp = unsafe.Pointer(getargp()) 
			d.fn()
		}
		p.argp = nil

		if gp._defer != d {
			throw("bad defer entry in panic")
		}
		d._panic = nil

		pc := d.pc
		sp := unsafe.Pointer(d.sp)
		if done { //将_defer从G的延迟链表移除，释放对应的_defer构造体资源
			d.fn = nil
			gp._defer = d.link
			freedefer(d)
		}
		if p.recovered { //panic已经恢复
			gp._panic = p.link 
			if gp._panic != nil && gp._panic.goexit && gp._panic.aborted {
				// A normal recover would bypass/abort the Goexit.  Instead,
				// we return to the processing loop of the Goexit.
				gp.sigcode0 = uintptr(gp._panic.sp)
				gp.sigcode1 = uintptr(gp._panic.pc)
				mcall(recovery)
				throw("bypassed recovery failed") // mcall should not return
			}
			runningPanicDefers.Add(-1)
			// 从G中获取一个_defer构造体
			d := gp._defer
			var prev *_defer
			if !done { //如果未执行完毕，跳过当前的帧直接执行下一个
				prev = d
				d = d.link
			}
			for d != nil {
				if d.started { //如果启动退出循环
					break
				}
				if d.openDefer { //如果使用了 open-coded defers
					if prev == nil { //将_defer从G的延迟链表移除释放_defer
						gp._defer = d.link
					} else {
						prev.link = d.link
					}
					newd := d.link
					freedefer(d)
					d = newd
				} else {
					prev = d
					d = d.link
				}
			}

			gp._panic = p.link //上面有对应的赋值，又重新赋了一遍没啥用
			for gp._panic != nil && gp._panic.aborted { //循环G中的_panic链表，去掉已经被标记中止的_panic
				gp._panic = gp._panic.link
			}
			if gp._panic == nil { // 如果当前G没有panic, 重置信号为0
				gp.sig = 0
			}
			// 将恢复帧发送给recovery.
			gp.sigcode0 = uintptr(sp)
			gp.sigcode1 = pc
			mcall(recovery)
			throw("recovery failed") // mcall should not return
		}
	}

	// 没有更多的延迟调用，现在采用传统的 panic 方式
	// 由于在冻结世界之后调用任意用户代码是不安全的，
	// 我们调用 preprintpanics 来调用所有必要的 Error
	// 和 String 方法，以在 startpanic 之前准备好 panic 字符串。
	preprintpanics(gp._panic)
	fatalpanic(gp._panic) //触发致命的 panic
	*(*int)(nil) = 0 //为了消除编译器的错误提示
}

当我们调度recover时，Go的编译器会将这段代码翻译为CALL runtime.gorecover(SB)

gorecover源码与解读

//代码位置 $GOROOT/src/runtime/panic.go L:1045
func gorecover(argp uintptr) any {
	gp := getg() //获取当前G
	p := gp._panic // 从当前G中获取一个_panic
	// 如果G存在panic，它的状态不为中止，还未进行painc捕获，函数调用参数相同
	if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
		p.recovered = true
		return p.arg
	}

	return nil
}

总结

从上面的源码我们可以了解到panic的大致逻辑，当使用panic关键词时，将painc加入到G的_panic链表中去. 调度时 defer func() {recover()}()，会改写_painc中的recovered字段，可恢复的panic必须要recover的配合。 而且这个recover必须位于同一goroutine的直接调用链上，否则无法对 panic 进行恢复，未写完有些细节点还是没读懂，后续查阅资料补充。