Golang之defer 延遲調用操作

Posted on by

前言

defer語句被用於預定對一個函數的調用。我們把這類被defer語句調用的函數稱為延遲函數。而defer 延遲語句在其他編程語言裡好像沒有見到。應該是屬於 Go 語言裡的獨有的關鍵字。但用法類似於面向對象編程語言 Java 和 C# 的 finally 語句塊。

下面對defer進行介紹。

defer特性

1. 關鍵字 defer 用於註冊延遲調用。

2. 這些調用直到 return 前才被執。因此，可以用來做資源清理。

3. 多個defer語句，按先進後出的方式執行。

1.延遲調用

用法很簡單，隻需要在函數前面加上 defer就行，就能實現將這個 該函數的調用延遲到當前函數執行完後再執行。例如：

package main 
import (
 "fmt"
)
func myFunc(){
 fmt.Println("minger")
}
func main(){
 defer myFunc() //等價於defer fmt.Println("minger")
 fmt.Println("程序猿編碼")
}

編譯運行：

2.defer 與 return 孰先孰後

defer 和 return 到底是哪個先調用？先看看例子：

package main 
import (
 "fmt"
)
var name string = "go"
func myFunc() string {
  defer func() {
    name = "python"
  }()
  fmt.Println("myFunc 函數裡的name：", name)
  return name
}
func main() {
  myName := myFunc()
  fmt.Println("main 函數裡的name: ", name)
  fmt.Println("main 函數裡的myname: ", myName )

編譯運行：

來看看打印信息，第一行輸出，name 此時還是全局變量，值還是go

第二行輸出，在 defer 裡改變瞭全局變量，此時name的值已經變成瞭 python

重點在第三行，為什麼輸出的是 go ？

解釋隻有一個，那就是 defer 是return 後才調用的。所以在執行 defer 前，myName 已經被賦值成 go 瞭。

3.多個defer 逆序執行

還是老規矩先來上代碼，看看輸出信息，例子：

package main 
import (
 "fmt"
)
func main(){
 name := "go"
 defer fmt.Println(name)
 name = "C/C++"
 defer fmt.Println(name)
 name = "Python"
 fmt.Println(name)
}

編譯輸出：

可見 多個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？

往往我們在編程的時候，經常需要打開一些資源，比如數據庫連接、文件、鎖等，這些資源需要在用完之後釋放掉，否則會造成內存泄漏。

因此我們有時會忘記關閉這些資源。Golang直接在語言層面提供defer關鍵字，在打開資源語句的下一行，就可以直接用defer語句來註冊函數結束後執行關閉資源的操作。

defer用途

1. 關閉文件句柄

2. 鎖資源釋放

3. 數據庫連接釋放

defer的使用其實非常簡單，來看看一個簡單用途：

package main
import (
 "log"
 "os"
)
func main() {
 f, err := os.OpenFile("text.txt", os.O_RDWR|os.O_APPEND|os.O_CREATE, 0666) //文件沒有就創建，文件存在就追加
 if err != nil {
 log.Fatal(err)
 }
 defer f.Close()
 f.WriteString("程序猿編碼\n")
}

編譯輸出：

在打開文件的語句附近，用defer語句關閉文件。這樣，在函數結束之前，會自動執行defer後面的語句來關閉文件。

當然，defer會有小小地延遲，對時間要求特別特別特別高的程序，可以避免使用它。

總結

defer 語句經常使用於成對的操作，比如打開和關閉，連接和斷開，加鎖和解鎖，即便是再復雜的控制流，資源在任何情況下都能夠正確釋放。

補充：Golang中defer的三個實戰要點

前言

Golang中的defer是使用頻次比較高的，能創造出延遲生效特效的一種方式。

defer也有自己的矯情，需要註意的。

本文將從通過代碼的方式來說明defer的三點矯情。

1.defer的生效順序

2.defer與return,函數返回值之間的順序

3.defer定義和執行兩個步驟，做的事情。

正文

1.defer的生效順序

先說結論：defer的執行順序是倒序執行（同入棧先進後出）

func main() {
 defer func() {
 fmt.Println("我後出來")
 }()
 defer func() {
 fmt.Println("我先出來")
 }()
}

執行後打印出：

我先出來

我後出來

2.defer與return,函數返回值之間的順序

先說結論：return最先執行->return負責將結果寫入返回值中->接著defer開始執行一些收尾工作->最後函數攜帶當前返回值退出

返回值的表達方式，我們知道根據是否提前聲明有兩種方式：一種是func test() int 另一種是 func test() (i int)，所以兩種情況都來說說

func test() int
func main() {
 fmt.Println("main:", test())
}
func test() int {
 var i int
 defer func() {
 i++
 fmt.Println("defer2的值:", i)
 }()
 defer func() {
 i++
 fmt.Println("defer1的值:", i)
 }()
 return i
}

輸出：

defer1的值: 1

defer2的值: 2

main: 0

詳解：return的時候已經先將返回值給定義下來瞭，就是0，由於i是在函數內部聲明所以即使在defer中進行瞭++操作，也不會影響return的時候做的決定。

func test() (i int)
func main() {
 fmt.Println("main:", test())
}
func test() (i int) {
 defer func() {
 i++
 fmt.Println("defer2的值:", i)
 }()
 defer func() {
 i++
 fmt.Println("defer1的值:", i)
 }()
 return i
}

輸出：

defer1的值: 1

defer2的值: 2

main: 2

詳解：由於返回值提前聲明瞭，所以在return的時候決定的返回值還是0，但是後面兩個defer執行後進行瞭兩次++，將i的值變為2，待defer執行完後，函數將i值進行瞭返回。

3.defer定義和執行兩個步驟，做的事情

先說結論：會先將defer後函數的參數部分的值(或者地址)給先下來【你可以理解為()裡頭的會先確定】，後面函數執行完，才會執行defer後函數的{}中的邏輯

func test(i *int) int {
 return *i
}
func main(){
 var i = 1
 // defer定義的時候test(&i)的值就已經定瞭，是1，後面就不會變瞭
 defer fmt.Println("i1 =" , test(&i))
 i++
 // defer定義的時候test(&i)的值就已經定瞭，是2，後面就不會變瞭
 defer fmt.Println("i2 =" , test(&i))
 // defer定義的時候，i就已經確定瞭是一個指針類型，地址上的值變瞭，這裡跟著變
 defer func(i *int) {
 fmt.Println("i3 =" , *i)
 }(&i)
 // defer定義的時候i的值就已經定瞭，是2，後面就不會變瞭
 defer func(i int) {
 //defer 在定義的時候就定瞭
 fmt.Println("i4 =" , i)
 }(i)
 defer func() {
 // 地址，所以後續跟著變
 var c = &i
 fmt.Println("i5 =" , *c)
 }()
 
 // 執行瞭 i=11 後才調用，此時i值已是11
 defer func() {
 fmt.Println("i6 =" , i)
 }()
 i = 11
}

以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：