前言

defer是golang語言中的關鍵字，用于資源的釋放，會在函數返回之前進行調用。

一般采用如下模式：

f,err := os.Open(filename)
if err != nil {
  panic(err)
}
defer f.Close()

如果有多個defer表達式，調用順序類似于棧，越后面的defer表達式越先被調用。

延時調用函數的語法如下:

defer func_name(param-list)

當一個函數調用前有關鍵字 defer 時, 那么這個函數的執行會推遲到包含這個 defer 語句的函數即將返回前才執行. 例如:

func main() {
  defer fmt.Println("Fourth")
  fmt.Println("First")
  fmt.Println("Third")
}

最后打印順序如下:

First
Second
Third

需要注意的是, defer 調用的函數參數的值 defer 被定義時就確定了.

例如:

i := 1
defer fmt.Println("Deferred print:", i)
i++
fmt.Println("Normal print:", i)

打印的內容如下:

Normal print: 2
Deferred print: 1

因此我們知道, 在 "defer fmt.Println("Deferred print:", i)" 調用時, i 的值已經確定了, 因此相當于 defer fmt.Println("Deferred print:", 1) 了.

需要強調的時, defer 調用的函數參數的值在 defer 定義時就確定了, 而 defer 函數內部所使用的變量的值需要在這個函數運行時才確定.

例如:

func f1() (r int) {
  r = 1
  defer func() {
    r++
    fmt.Println(r)
  }()
  r = 2
  return
}

func main() {
  f1()
}

上面的例子中, 最終打印的內容是 "3", 這是因為在 "r = 2" 賦值之后, 執行了 defer 函數, 因此在這個函數內, r 的值是2了, 自增后變為3.

defer 順序

如果有多個defer 調用, 則調用的順序是先進后出的順序, 類似于入棧出棧一樣:

func main() {
  defer fmt.Println(1)
  defer fmt.Println(2)
  defer fmt.Println(3)
  defer fmt.Println(4)
}

最先執行的是 "fmt.Println(4)" , 接著是 "fmt.Println(3)" 依次類推, 最后的輸出如下:

4
3
2
1

defer 注意要點

defer 函數調用的執行時機是外層函數設置返回值之后, 并且在即將返回之前.

例如:

func f1() (r int) {
  defer func() {
    r++
  }()
  return 0
}
func main() {
  fmt.Println(f1())
}

上面 fmt.Println(f1()) 打印的是什么呢? 很多朋友可能會認為打印的是0, 但是正確答案是 1. 這是為什么呢?

要弄明白這個問題, 我們需要牢記兩點

     1、defer 函數調用的執行時機是外層函數設置返回值之后, 并且在即將返回之前

     2、return XXX 操作并不是原子的.

我們將上面的例子改寫一下大家就很明白了:

func f1() (r int) {
  defer func() {
    r++
  }()
  r = 0
  return
}

當進行賦值操作 "r = 0" 后, 才調用 defer 函數, 最后才是返回語句.

因此上面的代碼等效于:

func f1() (r int) {
  r = 0
  func() {
    r++
  }()
  return
}

接下來我們再來看一個更有意思的例子:

func double(x int) int {
  return x + x
}

func triple(x int) (r int) {
  defer func() {
    r += x
  }()
  return double(x)
}

func main() {
  fmt.Println(triple(3))
}

如果我們已經理解了上面所說的內容的話, 那么 triple 函數就很好理解了, 它實際上是:

func triple(x int) (r int) {
  r = double(x)
  func() {
    r += x
  }()
  return
}

defer 表達式的使用場景

defer 通常用于 open/close, connect/disconnect, lock/unlock 等這些成對的操作, 來保證在任何情況下資源都被正確釋放. 在這個角度來說, defer 操作和 Java 中的 try ... finally 語句塊有異曲同工之處.

例如:

var mutex sync.Mutex
var count = 0

func increment() {
  mutex.Lock()
  defer mutex.Unlock()
  count++
}

在increment 函數中, 我們為了避免競態條件的出現, 而使用了 Mutex 進行加鎖. 而在進行并發編程時, 加鎖了卻忘記(或某種情況下 unlock 沒有被執行), 往往會造成災難性的后果. 為了在任意情況下, 都要保證在加鎖操作后, 都進行對應的解鎖操作, 我們可以使用 defer 調用解鎖操作.

總結

以上就是這篇文章的全部內容，希望對大家的學習或者工作帶來一定的幫助。如果有疑問大家可以留言交流。