今天我們講講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)
}

我們再來總結一下整個流程：

1. 先建立一個_panic結構體，載入到連結串列的表頭
2. 遍歷當前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捕獲

參考

1. Go語言聖經.
2. Go語言高階程式設計.