今天我們講講golang中panic例外，以及recover對例外的捕獲，由于panic、recover、defer之間非常親密，所以今天就放在一起講解，這里會涉及到一些defer的知識，有興趣可以看我的另一篇關于defer的文章 Golang中defer的實作原理.
Panic例外
Go的型別系統會在編譯時捕獲很多錯誤，但有些錯誤只能在運行時檢查，如陣列訪問越界、 空指標參考等，這些運行時錯誤會引起painc例外，
一般而言，當panic例外發生時，程式會中斷運行，并立即執行在該goroutine中被延遲的函式（defer 機制），隨后，程式崩潰并輸出日志資訊，
不是所有的panic例外都來自運行時，直接呼叫內置的panic函式也會引發panic例外
接下來，我們通過其匯編碼嘗試找出內置函式panic()的底層實作，
注意：我會把原始碼中每個方法的作用都注釋出來，可以參考注釋進行理解，
先撰寫一段簡單的代碼，并保存在panic.go檔案中
func main() {
panic("err")
}
然后使用以下命令編譯代碼：
go tool compile -S panic.go
0x0024 00036 (panic.go:10) PCDATA $2, $1
0x0024 00036 (panic.go:10) PCDATA $0, $0
0x0024 00036 (panic.go:10) LEAQ type.string(SB), AX
0x002b 00043 (panic.go:10) PCDATA $2, $0
0x002b 00043 (panic.go:10) MOVQ AX, (SP)
0x002f 00047 (panic.go:10) PCDATA $2, $1
0x002f 00047 (panic.go:10) LEAQ "".statictmp_0(SB), AX
0x0036 00054 (panic.go:10) PCDATA $2, $0
0x0036 00054 (panic.go:10) MOVQ AX, 8(SP)
0x003b 00059 (panic.go:10) CALL runtime.gopanic(SB)
我們可以看到panic()函式呼叫被替換成了runtime.gopanic()函式
看函式之前，我們先來看一下panic的結構體
runtime\runtime2.go:_panic
type _panic struct {
argp unsafe.Pointer // 指向在panic下運行的defer的引數的指標
arg interface{} // panic的引數
link *_panic // 鏈接到更早的panic，新panic添加到表頭
recovered bool // 該panic是否被recover
aborted bool // 該panic是否強制退出
}
接著，我們再來分析runtime.gopanic()函式
runtime\panic.go
func gopanic(e interface{}) {
//獲取當前goroutine
gp := getg()
...
//生成一個新的panic結構
var p _panic
p.arg = e
//指向更早的panic
p.link = gp._panic
//系結到goroutine
gp._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
atomic.Xadd(&runningPanicDefers, 1)
//回圈goroutine中的defer鏈表
for {
d := gp._defer
if d == nil {
break
}
//如果defer已經被呼叫
//如果該defer已經由較早的panic或者Goexit使用（表示引發了新的panic）
//則從鏈表中去除這個panic，之前的panic或Goexit將不會繼續運行，
if d.started {
if d._panic != nil {
d._panic.aborted = true
}
d._panic = nil
d.fn = nil
gp._defer = d.link
//釋放該defer
freedefer(d)
//跳過回圈，繼續下一個defer
continue
}
// 將defer標記已呼叫，但保留在串列中
//這樣 traceback 在堆疊增長或者 GC 的時候，能夠找到并更新 defer 的引數堆疊幀
// 并用 reflectcall 執行 d.fn
d.started = true
//記錄在 defer 中發生的 panic
//如果在 defer 的函式呼叫程序中又發生了新的 panic，那個 panic 會在鏈表中找到 d
// 然后標記 d._panic(指向當前的 panic) 為 aborted 狀態，
d._panic = (*_panic)(noescape(unsafe.Pointer(&p)))
p.argp = unsafe.Pointer(getargp(0))
//執行defer后面的fn，如果有recover()函式會執行recover
reflectcall(nil, unsafe.Pointer(d.fn), deferArgs(d), uint32(d.siz), uint32(d.siz))
p.argp = nil
// reflectcall 并沒有 panic，移除 d
if gp._defer != d {
throw("bad defer entry in panic")
}
//清空defer
d._panic = nil
d.fn = nil
//下一個defer
gp._defer = d.link
// trigger shrinkage to test stack copy. See stack_test.go:TestStackPanic
//GC()
//defer陳述句下一條陳述句的地址
pc := d.pc
//獲取rsp暫存器的值的指標
//必須是指標，以便在堆疊復制期間進行調整
sp := unsafe.Pointer(d.sp)
//釋放defer
freedefer(d)
//如果panic被recover
//會在gorecove 函式中已經修改為 true ，等會我們在講
if p.recovered {
//統計
atomic.Xadd(&runningPanicDefers, -1)
//下一個panic
gp._panic = p.link
// 已標記已中止的panic，q且保留在g.panic串列中，
//從串列中洗掉它們，
for gp._panic != nil && gp._panic.aborted {
gp._panic = gp._panic.link
}
//處理完所有panic
if gp._panic == nil { // 必須用信號完成
gp.sig = 0
}
// Pass information about recovering frame to recovery.
//將有關恢復幀的資訊傳遞給recovery函式
//通過之前傳入的 sp 和 pc 恢復
gp.sigcode0 = uintptr(sp)
gp.sigcode1 = pc
mcall(recovery)
throw("recovery failed") // mcall should not return
}
}
// ran out of deferred calls - old-school panic now
// Because it is unsafe to call arbitrary user code after freezing
// the world, we call preprintpanics to invoke all necessary Error
// and String methods to prepare the panic strings before startpanic.
preprintpanics(gp._panic)
//致命錯誤，終止程式
fatalpanic(gp._panic) // should not return
*(*int)(nil) = 0 // not reached
}
接著，我們再來看看它是如何通過recovery函式回復的
func recovery(gp *g) {
// Info about defer passed in G struct.
sp := gp.sigcode0
pc := gp.sigcode1
// d's arguments need to be in the stack.
if sp != 0 && (sp < gp.stack.lo || gp.stack.hi < sp) {
print("recover: ", hex(sp), " not in [", hex(gp.stack.lo), ", ", hex(gp.stack.hi), "]\n")
throw("bad recovery")
}
//讓這個 defer 結構體的 deferproc 位置的呼叫重新回傳
// 這次將回傳值修改為 1
gp.sched.sp = sp
gp.sched.pc = pc
gp.sched.lr = 0
gp.sched.ret = 1
//直接跳回到deferreturn那里去
gogo(&gp.sched)
}
我們再來總結一下整個流程：
- 先創建一個_panic結構體，加載到鏈表的表頭
- 遍歷當前goroutine的defer鏈表，
- 如果defer被標記為已呼叫，跳出當前回圈，進入下一個defer；
- 否則，將當前defer標記為已呼叫，同時執行defer后面的函式，如果有recover，則會通過之前創建defer時傳進來的deferproc 的下一潭訓編指令的地址（pc），以及函式呼叫堆疊堆疊頂的位置（sp）回傳到deferreturn的位置上去，否則，直接退出程式
Recover捕獲例外
通常來說，不應該對panic例外做任何處理，但有時，也許我們可以從例外中恢復，至少我們 可以在程式崩潰前，做一些操作，比如說：當web服務器遇到不可預料的嚴重問題時，在崩潰前應該將所有的連接關閉，服務器甚至可以將例外資訊反饋到客戶端，幫助除錯，
如果在defer函式中呼叫了內置函式recover，并且定義該defer陳述句的函式發生了panic例外，recover會使程式從panic中恢復，并回傳panic value，導致panic例外的函式不會繼續運行，但能正常回傳，在未發生panic時呼叫recover，recover會回傳nil，
recover函式的使用
1.recover必須與defer配合使用
func main() {
defer func() {
recover()
}()
panic("err")
}
類似于下面這種情況是不可以的：
func main() {
recover()
panic("觸發例外")
}
2.必須在defer函式中直接呼叫recover，不能進行封裝或者嵌套
func main() {
defer func() {
if r := MyRecover(); r != nil {
fmt.Println(r)
}
}()
panic("err")
}
func MyRecover() interface{} {
fmt.Println("recover")
return recover()
}
同樣，在defer中嵌套也不可以
func main() {
defer func() {
defer func() {
if r := recover(); r != nil {
fmt.Println(r)
}
}()
}()
panic("err")
}
如果我們直接在 defer 陳述句中呼叫 MyRecover 函式又可以正常作業了：
func main() {
//正常捕獲
defer MyRecover()
panic("err")
}
func MyRecover() interface{} {
fmt.Println("recover")
return recover()
}
但是，如果 defer 陳述句直接呼叫 recover 函式，依然不能正常捕獲例外：
func main() {
// 無法捕獲例外
defer recover()
panic("err")
}
必須要和有例外的堆疊幀只隔一個堆疊幀， recover 函式才能正常捕獲例外，換言之， recover 函式捕獲的是祖父一級呼叫函式堆疊幀的例外（剛好可以跨越一層 defer 函式）！
同時，為了避免不加區分的panic被恢復，可能導致系統漏洞的問題，最安全的做飯，就是對不同的錯誤型別分別處理
recover函式的原理
接下來，我們通過底層原始碼來看看它是如何做到這些限制的：
runtime\panic.go
func gorecover(argp uintptr) interface{} {
gp := getg()
p := gp._panic
//必須存在panic
//非runtime.Goexit()；
//panic還未被恢復
//argp == uintptr(p.argp)
//p.argp是最頂層的延遲函式呼叫的引數指標,argp是呼叫recover函式的引數地址，通常是defer函式的引數地址
//如果兩者相等，說明可以被恢復，這也是為什么recover必須跟在defer后面且recover 函式捕獲的是祖父一級呼叫函式堆疊幀的例外的原因
if p != nil && !p.goexit && !p.recovered && argp == uintptr(p.argp) {
//將recovered 標志改為true
p.recovered = true
return p.arg
}
return nil
}
gorecover函式比較簡單，就是將recovered設為true,說明已經defer后面的函式包含recover
總結
- recover函式在defer函式中
- recover函式被defer函式直接呼叫
- 如果包含多個defer函式，前面的defer通過recover()消除panic后，函式中剩余的defer仍然會執行，但不能再次recover()
- 連續呼叫panic，僅最后一個會被recover捕獲
參考
- Go語言圣經.
- Go語言高級編程.
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/192099.html
標籤：其他
上一篇：JS 的騷操作