go如何将int设成nil_大神是如何学习Go语言之panic和recover的原理

概述

在具体介绍和分析 Go 语言中的 panic 和 recover 的实现原理之前&＃xff0c;我们首先需要对它们有一些基本的了解&＃xff1b;panic 和 recover 两个关键字其实都是 Go 语言中的内置函数&＃xff0c;panic 能够改变程序的控制流&＃xff0c;当一个函数调用执行 panic 时&＃xff0c;它会立刻停止执行函数中其他的代码&＃xff0c;而是会运行其中的 defer 函数&＃xff0c;执行成功后会返回到调用方。

&＃xfffc;

对于上层调用方来说&＃xff0c;调用导致 panic 的函数其实与直接调用 panic 类似&＃xff0c;所以也会执行所有的 defer 函数并返回到它的调用方&＃xff0c;这个过程会一直进行直到当前 Goroutine 的调用栈中不包含任何的函数&＃xff0c;这时整个程序才会崩溃&＃xff0c;这个『恐慌过程』不仅会被显式的调用触发&＃xff0c;还会由于运行期间发生错误而触发。

然而 panic 导致的『恐慌』状态其实可以被 defer 中的 recover 中止&＃xff0c;recover 是一个只在 defer 中能够发挥作用的函数&＃xff0c;在正常的控制流程中&＃xff0c;调用 recover 会直接返回 nil 并且没有任何的作用&＃xff0c;但是如果当前的 Goroutine 发生了『恐慌』&＃xff0c;recover 其实就能够捕获到 panic 抛出的错误并阻止『恐慌』的继续传播。

概述这一小节的内容&＃xff0c;大部分直接来自于 Go 语言的博客 Defer, Panic, and Recover&＃xff0c;文章介绍了三种 Go 语言的常见关键字的常见使用场景。

常见使用

我们简单举两个例子简单了解一下 panic 和 recover 关键字的原理&＃xff0c;先来看第一个例子&＃xff1a;

func main() {
defer println("in main")
go func() {
defer println("in goroutine")
panic("")
}()

time.Sleep(1 * time.Second)
}

// in goroutine
// panic:
// ...


当我们运行这段代码时&＃xff0c;其实会发现 main 函数中的 defer 语句并没有执行&＃xff0c;执行的其实只有 Goroutine 中的 defer&＃xff0c;这其实就印证了 Go 语言在发生 panic 时只会执行当前协程中的 defer 函数&＃xff0c;这一点从 上一节 的源代码中也有所体现。

另一个例子就不止涉及 panic 和 defer 关键字了&＃xff0c;我们可以看一下 recover 是如何让当前函数重新『走向正轨』的&＃xff1a;

func main() {
defer fmt.Println("in main")
defer func() {
if err :&＃61; recover(); err !&＃61; nil {
fmt.Println(err)
}
}()

panic("unknown err")
}

// unknown err
// in main


从这个例子中我们可以看到&＃xff0c;recover 函数其实只是阻止了当前程序的崩溃&＃xff0c;但是当前控制流中的其他 defer 函数还会正常执行。

在最后&＃xff0c;我们需要知道的是可以在 defer 中连续多次调用 panic 函数&＃xff0c;这是一个 Go 语言中 panic 比较有意思的现象&＃xff1a;

func main() {
defer fmt.Println("in main")
defer func() {
panic("panic again")
}()

panic("panic once")
}

// in main
// panic: unknown err
// panic: again
//
// goroutine 1 [running]:
// main.main.func1()
// ...


当我们运行上述代码时&＃xff0c;从打印出的结果中可以看到当前的函数确实经历了两次 panic&＃xff0c;并且最外层的 defer 函数也能够正常执行

实现原理

既然已经介绍完了现象并且已经对 panic 和 recover 有了一定的了解&＃xff0c;接下来我们就会从 Go 语言的源代码层面对上一节中谈到的现象一探究竟&＃xff0c;这一节接下来的内容就是介绍这两个函数的实现原理了&＃xff0c;作为 Go 语言中的关键字&＃xff0c;我们还是会从编译期间和运行时两方面介绍它们。

panic 和 recover 关键字会在 编译期间 被 Go 语言的编译器转换成 OPANIC 和 ORECOVER 类型的节点并进一步转换成 gopanic 和 gorecover 两个运行时的函数调用。

数据结构

panic 在 Golang 中其实是由一个数据结构表示的&＃xff0c;每当我们调用一次 panic 函数都会创建一个如下所示的数据结构存储相关的信息&＃xff1a;

type _panic struct {
argp unsafe.Pointer
arg interface{}
link *_panic
recovered bool
aborted bool
}


1. argp 是指向 defer 调用时参数的指针&＃xff1b;

2. arg 是调用 panic 时传入的参数&＃xff1b;

3. link 指向了更早调用的 _panic 结构&＃xff1b;

4. recovered 表示当前 _panic 是否被 recover 恢复&＃xff1b;

5. aborted 表示当前的 panic 是否被强行终止&＃xff1b;

从数据结构中的 link 字段我们就可以推测出以下的结论 — panic 函数可以被连续多次调用&＃xff0c;它们之间通过 link 的关联形成一个链表。

崩溃

首先了解一下没有被 recover 的 panic 函数是如何终止整个程序的&＃xff0c;我们来看一下 gopanic 函数的实现

func gopanic(e interface{}) {
gp :&＃61; getg()
// ...
var p _panic
p.arg &＃61; e
p.link &＃61; gp._panic
gp._panic &＃61; (*_panic)(noescape(unsafe.Pointer(&p)))

for {
d :&＃61; gp._defer
if d &＃61;&＃61; nil {
break
}

d._panic &＃61; (*_panic)(noescape(unsafe.Pointer(&p)))

p.argp &＃61; unsafe.Pointer(getargp(0))
reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
p.argp &＃61; nil

d._panic &＃61; nil
d.fn &＃61; nil
gp._defer &＃61; d.link

pc :&＃61; d.pc
sp :&＃61; unsafe.Pointer(d.sp)
freedefer(d)
if p.recovered {
// ...
}
}

fatalpanic(gp._panic)
*(*int)(nil) &＃61; 0
}


我们暂时省略了 recover 相关的代码&＃xff0c;省略后的 gopanic 函数执行过程包含以下几个步骤&＃xff1a;

1. 获取当前 panic 调用所在的 Goroutine 协程&＃xff1b;

2. 创建并初始化一个 _panic 结构体&＃xff1b;

3. 从当前 Goroutine 中的链表获取一个 _defer 结构体&＃xff1b;

4. 如果当前 _defer 存在&＃xff0c;调用 reflectcall 执行 _defer 中的代码&＃xff1b;

5. 将下一位的 _defer 结构设置到 Goroutine 上并回到 3&＃xff1b;

6. 调用 fatalpanic 中止整个程序&＃xff1b;

fatalpanic 函数在中止整个程序之前可能就会通过 printpanics 打印出全部的 panic 消息以及调用时传入的参数&＃xff1a;

func fatalpanic(msgs *_panic) {
pc :&＃61; getcallerpc()
sp :&＃61; getcallersp()
gp :&＃61; getg()
var docrash bool
systemstack(func() {
if startpanic_m() && msgs !&＃61; nil {
atomic.Xadd(&runningPanicDefers, -1)

printpanics(msgs)
}
docrash &＃61; dopanic_m(gp, pc, sp)
})

if docrash {
crash()
}

systemstack(func() {
exit(2)
})

*(*int)(nil) &＃61; 0 // not reached
}


在 fatalpanic 函数的最后会通过 exit 退出当前程序并返回错误码 2&＃xff0c;不同的操作系统其实对 exit 函数有着不同的实现&＃xff0c;其实最终都执行了 exit 系统调用来退出程序。

恢复

到了这里我们已经掌握了 panic 退出程序的过程&＃xff0c;但是一个 panic 的程序也可能会被 defer 中的关键字 recover 恢复&＃xff0c;在这时我们就回到 recover 关键字对应函数 gorecover 的实现了&＃xff1a;

func gorecover(argp uintptr) interface{} {
p :&＃61; gp._panic
if p !&＃61; nil && !p.recovered && argp &＃61;&＃61; uintptr(p.argp) {
p.recovered &＃61; true
return p.arg
}
return nil
}


这个函数的实现其实非常简单&＃xff0c;它其实就是会修改 panic 结构体的 recovered 字段&＃xff0c;当前函数的调用其实都发生在 gopanic 期间&＃xff0c;我们重新回顾一下这段方法的实现&＃xff1a;

func gopanic(e interface{}) {
// ...

for {
// reflectcall

pc :&＃61; d.pc
sp :&＃61; unsafe.Pointer(d.sp)

// ...
if p.recovered {
gp._panic &＃61; p.link
for gp._panic !&＃61; nil && gp._panic.aborted {
gp._panic &＃61; gp._panic.link
}
if gp._panic &＃61;&＃61; nil {
gp.sig &＃61; 0
}
gp.sigcode0 &＃61; uintptr(sp)
gp.sigcode1 &＃61; pc
mcall(recovery)
throw("recovery failed")
}
}

fatalpanic(gp._panic)
*(*int)(nil) &＃61; 0
}


上述这段代码其实从 _defer 结构体中取出了程序计数器 pc 和栈指针 sp 并调用 recovery 方法进行调度&＃xff0c;调度之前会准备好 sp、pc 以及函数的返回值&＃xff1a;

func recovery(gp *g) {
sp :&＃61; gp.sigcode0
pc :&＃61; gp.sigcode1

gp.sched.sp &＃61; sp
gp.sched.pc &＃61; pc
gp.sched.lr &＃61; 0
gp.sched.ret &＃61; 1
gogo(&gp.sched)
}


在 defer 一节中我们曾经介绍过 deferproc 的实现&＃xff0c;作为创建并初始化 _defer 结构体的函数&＃xff0c;它会将 deferproc 函数开始位置对应的栈指针 sp 和程序计数器 pc 存储到 _defer 结构体中&＃xff0c;这里的 gogo 函数其实就会跳回 deferproc&＃xff1a;

TEXT runtime·gogo(SB), NOSPLIT, $8-4
MOVL buf&＃43;0(FP), BX // gobuf
MOVL gobuf_g(BX), DX
MOVL 0(DX), CX // make sure g !&＃61; nil
get_tls(CX)
MOVL DX, g(CX)
MOVL gobuf_sp(BX), SP // restore SP
MOVL gobuf_ret(BX), AX
MOVL gobuf_ctxt(BX), DX
MOVL $0, gobuf_sp(BX) // clear to help garbage collector
MOVL $0, gobuf_ret(BX)
MOVL $0, gobuf_ctxt(BX)
MOVL gobuf_pc(BX), BX
JMP BX


这里的调度其实会将 deferproc 函数的返回值设置成 1&＃xff0c;在这时编译器生成的代码就会帮助我们直接跳转到调用方函数 return 之前并进入 deferreturn 的执行过程&＃xff0c;我们可以从 deferproc 的注释中简单了解这一过程&＃xff1a;

func deferproc(siz int32, fn *funcval) {
// ...

// deferproc returns 0 normally.
// a deferred func that stops a panic
// makes the deferproc return 1.
// the code the compiler generates always
// checks the return value and jumps to the
// end of the function if deferproc returns !&＃61; 0.
return0()
// No code can go here - the C return register has
// been set and must not be clobbered.
}


跳转到 deferreturn 函数之后&＃xff0c;程序其实就从 panic 的过程中跳出来恢复了正常的执行逻辑&＃xff0c;而 gorecover 函数也从 _panic 结构体中取出了调用 panic 时传入的 arg 参数。

总结

Go 语言中 panic 和 recover 的实现其实与 defer 关键字的联系非常紧密&＃xff0c;而分析程序的恐慌和恢复过程也比较棘手&＃xff0c;不是特别容易理解。在文章的最后我们还是简单总结一下具体的实现原理&＃xff1a;

1. 在编译过程中会将 panic 和 recover 分别转换成 gopanic 和 gorecover函数&＃xff0c;同时将 defer 转换成 deferproc 函数并在调用 defer 的函数和方法末尾增加 deferreturn 的指令&＃xff1b;

2. 在运行过程中遇到 gopanic 方法时&＃xff0c;会从当前 Goroutine 中取出 _defer 的链表并通过 reflectcall 调用用于收尾的函数&＃xff1b;

3. 如果在 reflectcall 调用时遇到了 gorecover 就会直接将当前的 _panic.recovered 标记成 true 并返回 panic 传入的参数(在这时 recover 就能够获取到 panic 的信息)&＃xff1b;

   1. 在这次调用结束之后&＃xff0c;gopanic 会从 _defer 结构体中取出程序计数器 pc 和栈指针 sp 并调用 recovery 方法进行恢复&＃xff1b;

   2. recovery 会根据传入的 pc 和 sp 跳转到 deferproc 函数&＃xff1b;

   3. 编译器自动生成的代码会发现 deferproc 的返回值不为 0&＃xff0c;这时就会直接跳到 deferreturn 函数中并恢复到正常的控制流程(依次执行剩余的 defer 并正常退出)&＃xff1b;

4. 如果没有遇到 gorecover 就会依次遍历所有的 _defer 结构&＃xff0c;并在最后调用 fatalpanic 中止程序、打印 panic 参数并返回错误码 2&＃xff1b;

整个过程涉及了一些 Go 语言底层相关的知识并且发生了非常多的跳转&＃xff0c;相关的源代码也不是特别的直接&＃xff0c;阅读起来也比较晦涩&＃xff0c;不过还是对我们理解 Go 语言的错误处理机制有着比较大的帮助。

Reference

• Dive into stack and defer/panic/recover in go

• Defer, Panic, and Recover

推荐阅读

• 大神是如何学习 Go 语言之浅谈 select 的实现原理

• 大神是如何学习 Go 语言之 Channel 实现原理精要

喜欢本文的朋友&＃xff0c;欢迎关注“Go语言中文网”&＃xff1a;

Go语言中文网启用微信学习交流群&＃xff0c;欢迎加微信&＃xff1a;274768166