歡迎光臨
每天分享高質量文章

Golang之輕鬆化解defer的溫柔陷阱

defer是Go語言提供的一種用於註冊延遲呼叫的機制:讓函式或陳述句可以在當前函式執行完畢後(包括通過return正常結束或者panic導致的異常結束)執行。深受Go開發者的歡迎,但一不小心就會掉進它的溫柔陷阱,只有深入理解它的原理,我們才能輕鬆避開,寫出漂亮穩健的代碼。

為了更好的閱讀體驗,按慣例我手動貼上文章目錄:

 

 

什麼是defer?

defer是Go語言提供的一種用於註冊延遲呼叫的機制:讓函式或陳述句可以在當前函式執行完畢後(包括通過return正常結束或者panic導致的異常結束)執行。

defer陳述句通常用於一些成對操作的場景:打開連接/關閉連接;加鎖/釋放鎖;打開檔案/關閉檔案等。

defer在一些需要回收資源的場景非常有用,可以很方便地在函式結束前做一些清理操作。在打開資源陳述句的下一行,直接一句defer就可以在函式傳回前關閉資源,可謂相當優雅。

  1. f, _ := os.Open("defer.txt")
  2. defer f.Close()

註意:以上代碼,忽略了err, 實際上應該先判斷是否出錯,如果出錯了,直接return. 接著再判斷 f是否為空,如果 f為空,就不能呼叫 f.Close()函式了,會直接panic的。

為什麼需要defer?

程式員在編程的時候,經常需要打開一些資源,比如資料庫連接、檔案、鎖等,這些資源需要在用完之後釋放掉,否則會造成記憶體泄漏。

但是程式員都是人,是人就會犯錯。因此經常有程式員忘記關閉這些資源。Golang直接在語言層面提供 defer關鍵字,在打開資源陳述句的下一行,就可以直接用 defer陳述句來註冊函式結束後執行關閉資源的操作。因為這樣一顆“小小”的語法糖,程式員忘寫關閉資源陳述句的情況就大大地減少了。

怎樣合理使用defer?

defer的使用其實非常簡單:

  1. f,err := os.Open(filename)
  2. if err != nil {
  3.    panic(err)
  4. }
  5.  
  6. if f != nil {
  7.    defer f.Close()
  8. }

在打開檔案的陳述句附近,用defer陳述句關閉檔案。這樣,在函式結束之前,會自動執行defer後面的陳述句來關閉檔案。

當然,defer會有小小地延遲,對時間要求特別特別特別高的程式,可以避免使用它,其他一般忽略它帶來的延遲。

defer進階

defer的底層原理是什麼?

我們先看一下官方對 defer的解釋:

Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usual and saved anew but the actual function is not invoked. Instead, deferred functions are invoked immediately before the surrounding function returns, in the reverse order they were deferred. If a deferred function value evaluates to nil, execution panics when the function is invoked, not when the “defer” statement is executed.

翻譯一下:每次defer陳述句執行的時候,會把函式“壓棧”,函式引數會被拷貝下來;當外層函式(非代碼塊,如一個for迴圈)退出時,defer函式按照定義的逆序執行;如果defer執行的函式為nil, 那麼會在最終呼叫函式的產生panic.

defer陳述句並不會馬上執行,而是會進入一個棧,函式return前,會按先進後出的順序執行。也說是說最先被定義的defer陳述句最後執行。先進後出的原因是後面定義的函式可能會依賴前面的資源,自然要先執行;否則,如果前面先執行,那後面函式的依賴就沒有了。

在defer函式定義時,對外部變數的取用是有兩種方式的,分別是作為函式引數和作為閉包取用。作為函式引數,則在defer定義時就把值傳遞給defer,並被cache起來;作為閉包取用的話,則會在defer函式真正呼叫時根據整個背景關係確定當前的值。

defer後面的陳述句在執行的時候,函式呼叫的引數會被儲存起來,也就是複製了一份。真正執行的時候,實際上用到的是這個複製的變數,因此如果此變數是一個“值”,那麼就和定義的時候是一致的。如果此變數是一個“取用”,那麼就可能和定義的時候不一致。

舉個例子:

  1. func main() {
  2.    var whatever [3]struct{}
  3.  
  4.    for i := range whatever {
  5.        defer func() {
  6.            fmt.Println(i)
  7.        }()
  8.    }
  9. }

執行結果:

  1. 2
  2. 2
  3. 2

defer後面跟的是一個閉包(後面會講到),i是“取用”型別的變數,最後i的值為2, 因此最後打印了三個2.

有了上面的基礎,我們來檢驗一下成果:

  1. type number int
  2.  
  3. func (n number) print()   { fmt.Println(n) }
  4. func (n *number) pprint() { fmt.Println(*n) }
  5.  
  6. func main() {
  7.    var n number
  8.  
  9.    defer n.print()
  10.    defer n.pprint()
  11.    defer func() { n.print() }()
  12.    defer func() { n.pprint() }()
  13.  
  14.    n = 3
  15. }

執行結果是:

  1. 3
  2. 3
  3. 3
  4. 0

第四個defer陳述句是閉包,取用外部函式的n, 最終結果是3;
第三個defer陳述句同第四個;
第二個defer陳述句,n是取用,最終求值是3.
第一個defer陳述句,對n直接求值,開始的時候n=0, 所以最後是0;

利用defer原理

有些情況下,我們會故意用到defer的先求值,再延遲呼叫的性質。想象這樣的場景:在一個函式里,需要打開兩個檔案進行合併操作,合併完後,在函式執行完後關閉打開的檔案句柄。

  1. func mergeFile() error {
  2.    f, _ := os.Open("file1.txt")
  3.    if f != nil {
  4.        defer func(f io.Closer) {
  5.            if err := f.Close(); err != nil {
  6.                fmt.Printf("defer close file1.txt err %v\n", err)
  7.            }
  8.        }(f)
  9.    }
  10.  
  11.    // ……
  12.  
  13.    f, _ = os.Open("file2.txt")
  14.    if f != nil {
  15.        defer func(f io.Closer) {
  16.            if err := f.Close(); err != nil {
  17.                fmt.Printf("defer close file2.txt err %v\n", err)
  18.            }
  19.        }(f)
  20.    }
  21.  
  22.    return nil
  23. }

上面的代碼中就用到了defer的原理,defer函式定義的時候,引數就已經複製進去了,之後,真正執行close()函式的時候就剛好關閉的是正確的“檔案”了,妙哉!可以想像一下如果不這樣將f當成函式引數傳遞進去的話,最後兩個陳述句關閉的就是同一個檔案了,都是最後一個打開的檔案。

不過在呼叫close()函式的時候,要註意一點:先判斷呼叫主體是否為空,否則會panic. 比如上面的代碼片段里,先判斷 f不為空,才會呼叫 Close()函式,這樣最安全。

defer命令的拆解

如果defer像上面介紹地那樣簡單(其實也不簡單啦),這個世界就完美了。事情總是沒這麼簡單,defer用得不好,是會跳進很多坑的。

理解這些坑的關鍵是這條陳述句:

  1. return xxx

上面這條陳述句經過編譯之後,變成了三條指令:

  1. 1. 傳回值 = xxx
  2. 2. 呼叫defer函式
  3. 3. 空的return

1,3步才是Return 陳述句真正的命令,第2步是defer定義的陳述句,這裡可能會操作傳回值。

下麵我們來看兩個例子,試著將return陳述句和defer陳述句拆解到正確的順序。

第一個例子:

  1. func f() (r int) {
  2.     t := 5
  3.     defer func() {
  4.       t = t + 5
  5.     }()
  6.     return t
  7. }

拆解後:

  1. func f() (r int) {
  2.     t := 5
  3.  
  4.     // 1. 賦值指令
  5.     r = t
  6.  
  7.     // 2. defer被插入到賦值與傳回之間執行,這個例子中傳回值r沒被修改過
  8.     func() {        
  9.         t = t + 5
  10.     }
  11.  
  12.     // 3. 空的return指令
  13.     return
  14. }

這裡第二步沒有操作傳回值r, 因此,main函式中呼叫f()得到5.

第二個例子:

  1. func f() (r int) {
  2.    defer func(r int) {
  3.          r = r + 5
  4.    }(r)
  5.    return 1
  6. }

拆解後:

  1. func f() (r int) {
  2.     // 1. 賦值
  3.     r = 1
  4.  
  5.     // 2. 這裡改的r是之前傳值傳進去的r,不會改變要傳回的那個r值
  6.     func(r int) {
  7.          r = r + 5
  8.     }(r)
  9.  
  10.     // 3. 空的return
  11.     return
  12. }

因此,main函式中呼叫f()得到1.

defer陳述句的引數

defer陳述句運算式的值在定義時就已經確定了。下麵展示三個函式:

  1. func f1() {
  2.    var err error
  3.  
  4.    defer fmt.Println(err)
  5.  
  6.    err = errors.New("defer error")
  7.    return
  8. }
  9.  
  10. func f2() {
  11.    var err error
  12.  
  13.    defer func() {
  14.        fmt.Println(err)
  15.    }()
  16.  
  17.    err = errors.New("defer error")
  18.    return
  19. }
  20.  
  21. func f3() {
  22.    var err error
  23.  
  24.    defer func(err error) {
  25.        fmt.Println(err)
  26.    }(err)
  27.  
  28.    err = errors.New("defer error")
  29.    return
  30. }
  31.  
  32. func main() {
  33.    f1()
  34.    f2()
  35.    f3()
  36. }

運行結果:

  1. defer error

第1,3個函式是因為作為函式引數,定義的時候就會求值,定義的時候err變數的值都是nil, 所以最後打印的時候都是nil. 第2個函式的引數其實也是會在定義的時候求值,只不過,第2個例子中是一個閉包,它取用的變數err在執行的時候最終變成 defer error了。關於閉包在本文後面有介紹。

第3個函式的錯誤還比較容易犯,在生產環境中,很容易寫出這樣的錯誤代碼。最後defer陳述句沒有起到作用。

閉包是什麼?

閉包是由函式及其相關取用環境組合而成的物體,即:

  1. 閉包=函式+取用環境

一般的函式都有函式名,但是匿名函式就沒有。匿名函式不能獨立存在,但可以直接呼叫或者賦值於某個變數。匿名函式也被稱為閉包,一個閉包繼承了函式宣告時的作用域。在Golang中,所有的匿名函式都是閉包。

有個不太恰當的例子,可以把閉包看成是一個類,一個閉包函式呼叫就是實體化一個類。閉包在運行時可以有多個實體,它會將同一個作用域里的變數和常量捕獲下來,無論閉包在什麼地方被呼叫(實體化)時,都可以使用這些變數和常量。而且,閉包捕獲的變數和常量是取用傳遞,不是值傳遞。

舉個簡單的例子:

  1. func main() {
  2.    var a = Accumulator()
  3.  
  4.    fmt.Printf("%d\n", a(1))
  5.    fmt.Printf("%d\n", a(10))
  6.    fmt.Printf("%d\n", a(100))
  7.  
  8.    fmt.Println("------------------------")
  9.    var b = Accumulator()
  10.  
  11.    fmt.Printf("%d\n", b(1))
  12.    fmt.Printf("%d\n", b(10))
  13.    fmt.Printf("%d\n", b(100))
  14.  
  15.  
  16. }
  17.  
  18. func Accumulator() func(int) int {
  19.    var x int
  20.  
  21.    return func(delta int) int {
  22.        fmt.Printf("(%+v, %+v) - ", &x, x)
  23.        x += delta
  24.        return x
  25.    }
  26. }

執行結果:

  1. (0xc420014070, 0) - 1
  2. (0xc420014070, 1) - 11
  3. (0xc420014070, 11) - 111
  4. ------------------------
  5. (0xc4200140b8, 0) - 1
  6. (0xc4200140b8, 1) - 11
  7. (0xc4200140b8, 11) - 111

閉包取用了x變數,a,b可看作2個不同的實體,實體之間互不影響。實體內部,x變數是同一個地址,因此具有“累加效應”。

defer配合recover

Golang被詬病比較多的就是它的error, 經常是各種error滿天飛。編程的時候總是會傳回一個error, 留給呼叫者處理。如果是那種致命的錯誤,比如程式執行初始化的時候出問題,直接panic掉,省得上線運行後出更大的問題。

但是有些時候,我們需要從異常中恢復。比如服務器程式遇到嚴重問題,產生了panic, 這時我們至少可以在程式崩潰前做一些“掃尾工作”,如關閉客戶端的連接,防止客戶端一直等待等等。

panic會停掉當前正在執行的程式,不只是當前協程。在這之前,它會有序地執行完當前協程defer串列里的陳述句,其它協程里掛的defer陳述句不作保證。因此,我們經常在defer里掛一個recover陳述句,防止程式直接掛掉,這起到了 try...catch的效果。

註意,recover()函式只在defer的背景關係中才有效(且只有通過在defer中用匿名函式呼叫才有效),直接呼叫的話,只會傳回 nil.

  1. func main() {
  2.    defer fmt.Println("defer main")
  3.    var user = os.Getenv("USER_")
  4.  
  5.    go func() {
  6.        defer func() {
  7.            fmt.Println("defer caller")
  8.            if err := recover(); err != nil {
  9.                fmt.Println("recover success. err: ", err)
  10.            }
  11.        }()
  12.  
  13.        func() {
  14.            defer func() {
  15.                fmt.Println("defer here")
  16.            }()
  17.  
  18.            if user == "" {
  19.                panic("should set user env.")
  20.            }
  21.  
  22.            // 此處不會執行
  23.            fmt.Println("after panic")
  24.        }()
  25.    }()
  26.  
  27.    time.Sleep(100)
  28.    fmt.Println("end of main function")
  29. }

上面的panic最終會被recover捕獲到。這樣的處理方式在一個http server的主流程常常會被用到。一次偶然的請求可能會觸發某個bug, 這時用recover捕獲panic, 穩住主流程,不影響其他請求。

程式員通過監控獲知此次panic的發生,按時間點定位到日誌相應位置,找到發生panic的原因,三下五除二,修複上線。一看四周,大家都埋頭乾自己的事,簡直完美:偷偷修複了一個bug, 沒有發現!嘿嘿!

後記

defer非常好用,一般情況下不會有什麼問題。但是只有深入理解了defer的原理才會避開它的溫柔陷阱。掌握了它的原理後,就會寫出易懂易維護的代碼。

參考資料

【defer那些事】https://xiaozhou.net/something-about-defer-2014-05-25.html
【defer代碼案例】https://tiancaiamao.gitbooks.io/go-internals/content/zh/03.4.html
【閉包】https://www.kancloud.cn/liupengjie/go/576456
【閉包】http://blog.51cto.com/speakingbaicai/1703229
【閉包】https://blog.csdn.net/zhangzhebjut/article/details/25181151
【延遲】http://liyangliang.me/posts/2014/12/defer-in-golang/
【defer三條原則】https://leokongwq.github.io/2016/10/15/golang-defer.html
【defer代碼例子】https://juejin.im/post/5b948b3e6fb9a05d3827beda
【defer panic】https://ieevee.com/tech/2017/11/23/go-panic.html
【defer panic】https://zhuanlan.zhihu.com/p/33743255

Gopher China 2019 最新資訊

Gopher China 2019 講師專訪 -晁岳攀

【重磅】Gopher China 2019 大會講師及議題揭曉

重磅!會前一天培訓講師揭曉:Dave&William;

探探Gopher China 2019大會全面啟動

赞(0)

分享創造快樂