Golang 高效實踐之defer、panic、recover實踐
前言
我們知道Golang處理異常是用error返回的方式，然後呼叫方根據error的值走不同的處理邏輯。但是，如果程式觸發其他的嚴重異常，比如說陣列越界，程式就要直接崩潰。Golang有沒有一種異常捕獲和恢復機制呢？這個就是本文要講的panic和recover。其中recover要配合defer使用才能發揮出效果。
Defer
Defer語句將一個函式放入一個列表（用棧表示其實更準確）中，該列表的函式在環繞defer的函式返回時會被執行。defer通常用於簡化函式的各種各樣清理動作，例如關閉檔案，解鎖等等的釋放資源的動作。例如下面的這個函式開啟兩個檔案，從一個檔案拷貝內容到另外的一個檔案：
func CopyFile(dstName, srcName string) (written int64, err error) {
src, err := os.Open(srcName)
if err != nil {
return
}
dst, err := os.Create(dstName)
if err != nil {
return
}
written, err = io.Copy(dst, src)
dst.Close()
src.Close()
return
}這段程式碼可以工作，但是有一個bug。如果呼叫os.Create失敗，函式將會直接返回，並沒有關閉srcName檔案。修復的方法很簡單，可以把src.Close的呼叫放在第二個return語句前面。但是當我們程式的分支比較多的時候，也就是說當該函式還有幾個其他的return語句時，就需要在每個分支return前都要加上close動作。這樣使得資源的清理非常繁瑣而且容易遺漏。所以Golang引入了defer語句：
func CopyFile(dstName, srcName string) (written int64, err error) {
src, err := os.Open(srcName)
if err != nil {
return
}
defer src.Close()
dst, err := os.Create(dstName)
if err != nil {
return
}
defer dst.Close()
return io.Copy(dst, src)
}在每個資源申請成功的後面都加上defer自動清理，不管該函式都多少個return，資源都會被正確的釋放，例如上述例子的檔案一定會被關閉。
關閉defer語句，有三條簡單的規則：
1.defer的函式在壓棧的時候也會儲存引數的值，並非在執行時取值。
func a() {
i := 0
defer fmt.Println(i)
i++
return
}
例如該示例中，變數i會在defer時就被儲存起來，所以defer函式執行時i的值是0.即便後面i的值變為了1，也不會影響之前的拷貝。
2.defer函式呼叫的順序是後進先出。
func b() {
for i := 0; i < 4; i++ {
defer fmt.Print(i)
}
}
函式輸出3210
3.defer函式可以讀取和重新賦值函式的命名返回引數。
func c() (i int) {
defer func() { i++ }()
return 1
}
這個例子中，defer函式中在函式返回時對命名返回值i進行了加1操作，因此函式返回值是2.可能你會有疑問，規則1不是說會在defer時儲存i的值嗎？儲存的i是0，那加1操作之後也是1啊。這裡就是閉包的魅力，i的值會被立馬儲存，但是儲存的是i的引用，也可以理解為指標。當實際執行加1操作時，i的值其實被return置為了1，defer執行了加1操作i的值也就變成了2.
Panic
Panic是內建的停止控制流的函式。相當於其他程式語言的拋異常操作。當函式F呼叫了panic，F的執行會被停止，在F中panic前面定義的defer操作都會被執行，然後F函式返回。對於呼叫者來說，呼叫F的行為就像呼叫panic（如果F函式內部沒有把panic recover掉）。如果都沒有捕獲該panic，相當於一層層panic，程式將會crash。panic可以直接呼叫，也可以是程式執行時錯誤導致，例如陣列越界。
Recover
Recover是一個從panic恢復的內建函式。Recover只有在defer的函式裡面才能發揮真正的作用。如果是正常的情況（沒有發生panic），呼叫recover將會返回nil並且沒有任何影響。如果當前的goroutine panic了，recover的呼叫將會捕獲到panic的值，並且恢復正常執行。
例如下面這個例子：
package main
import "fmt"
func main() {
f()
fmt.Println("Returned normally from f.")
}
func f() {
defer func() {
if r := recover(); r != nil {
fmt.Println("Recovered in f", r)
}
}()
fmt.Println("Calling g.")
g(0)
fmt.Println("Returned normally from g.")
}
func g(i int) {
if i > 3 {
fmt.Println("Panicking!")
panic(fmt.Sprintf("%v", i))
}
defer fmt.Println("Defer in g", i)
fmt.Println("Printing in g", i)
g(i + 1)
}
函式g接受引數i，如果i大於3時觸發panic，否則對i進行加1操作。函式f的defer函式裡面呼叫了recover並且列印recover的值（非nil的話）。
程式將會輸出：
Calling g. Printing in g 0 Printing in g 1 Printing in g 2 Printing in g 3 Panicking! Defer in g 3 Defer in g 2 Defer in g 1 Defer in g 0 Recovered in f 4 Returned normally from f.
Panic和recover可以接受任何型別的值，因為定義為interface{}：
func panic(v interface{})
func recover() interface{}
所以工作模式相當於：
panic(value)->recover()->value
傳遞給panic的value最終由recover捕獲。
另外defer可以配合鎖的使用來確保鎖的釋放，例如：
mu.Lock()
Defer mu.Unlock()
需要注意的是這樣會延長鎖的釋放時間（需要等到函式return）。
容易踩坑的一些例子
通過上面的說明，我們已經對defer，panic和recover有了比較清晰的認識，下面通過一些實戰中容易踩坑的例子來加深下印象。
在迴圈裡面使用defer
不要在迴圈裡面使用defer，除非你真的確定defer的工作流程，例如：
只有當函式返回時defer的函式才會被執行，如果在for迴圈裡面defer定義的函式會不斷的壓棧，可能會爆棧而導致程式異常。
解決方法1：將defer移動到迴圈之外
解決方法2：構造一層新的函式包裹defer
defer方法
沒有指標的情況：
type Car struct {
model string
}
func (c Car) PrintModel() {
fmt.Println(c.model)
}
func main() {
c := Car{model: "DeLorean DMC-12"}
defer c.PrintModel()
c.model = "Chevrolet Impala"
}
程式輸出DeLorean DMC-12。根據我們前面講的內容，defer的時候會把函式和參考拷貝一份儲存起來，所以c.model的值後面改變也不會影響defer的執行。
有指標的情況：
Car PrintModel()方法定義改為：
func (c *Car) PrintModel() {
fmt.Println(c.model)
}
程式將會輸出Chevrolet Impala。這些defer雖然將函式和引數儲存了起來，但是由於引數的值本身是針對，隨意後面的改動會影響到defer函式的行為。
同理的例子還有：
for i := 0; i < 3; i++ {
defer func() {
fmt.Println(i)
}()
}
程式將會輸出：
3 3 3
因為閉包引用匿名函式外面的變數相當於是指標引用，得到的是變數的地址，實際到defer真正執行時，指標指向的內容已經發生的變化：
解決的方法：
for i := 0; i < 3; i++ {
defer func(i int) {
fmt.Println(i)
}(i)
}
或者：
for i := 0; i < 3; i++ {
defer fmt.Println(i)
}
程式輸出：
2 1 0
這裡就不會用到閉包的上下文引用特性，是正經的函式引數拷貝傳遞，所以不會有問題。
defer中修改函式error返回值
package main
import (
"errors"
"fmt"
)
func main() {
{
err := release()
fmt.Println(err)
}
{
err := correctRelease()
fmt.Println(err)
}
}
func release() error {
defer func() error {
return errors.New("error")
}()
return nil
}
func correctRelease() (err error) {
defer func() {
err = errors.New("error")
}()
return nil
}
release函式中error的值並不會被defer的return返回，因為匿名返回值在defer執行前就已經宣告好並複製為nil。correctRelease函式能夠修改返回值是因為閉包的特性，defer中的err是實際的返回值err地址引用，指向的是同一個變數。defer修改程式返回值error一般用在和recover搭配中，上述的情況屬於濫用defer的一種情況，其實error函式值可以直接在程式的return中修改，不用defer。
總結
文章介紹了defer、panic和recover的原理和用法，並且在最後給出了一些在實際應用的實踐建議，不要濫用defer，注意defer搭配閉包時的一些特性。
參考
https://blog.golang.org/defer-panic-and-recover
https://blog.learngoprogramming.com/gotchas-of-defer-in-go-1-8d070894cb01
https://blog.learngoprogramming.com/5-gotchas-of-defer-in-go-golang-part-ii-cc550f6ad9aa
https://blog.learngoprogramming.com/golang-defer-simplified-77d3b2b817ff
https://blog.learngoprogramming.com/5-gotchas-of-defer-in-go-golang-part-iii-36a1ab3d6ef1