前言

defer是golang語言中的關(guān)鍵字，用于資源的釋放，會在函數(shù)返回之前進行調(diào)用。

一般采用如下模式：

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

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

延時調(diào)用函數(shù)的語法如下:

defer func_name(param-list)

當一個函數(shù)調(diào)用前有關(guān)鍵字 defer 時, 那么這個函數(shù)的執(zhí)行會推遲到包含這個 defer 語句的函數(shù)即將返回前才執(zhí)行. 例如:

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

最后打印順序如下:

First
Second
Third

需要注意的是, defer 調(diào)用的函數(shù)參數(shù)的值 defer 被定義時就確定了.

例如:

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

打印的內(nèi)容如下:

Normal print: 2
Deferred print: 1

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

需要強調(diào)的時, defer 調(diào)用的函數(shù)參數(shù)的值在 defer 定義時就確定了, 而 defer 函數(shù)內(nèi)部所使用的變量的值需要在這個函數(shù)運行時才確定.

例如:

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

func main() {
  f1()
}

上面的例子中, 最終打印的內(nèi)容是 "3", 這是因為在 "r = 2" 賦值之后, 執(zhí)行了 defer 函數(shù), 因此在這個函數(shù)內(nèi), r 的值是2了, 自增后變?yōu)?.

defer 順序

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

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

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

4
3
2
1

defer 注意要點

defer 函數(shù)調(diào)用的執(zhí)行時機是外層函數(shù)設(shè)置返回值之后, 并且在即將返回之前.

例如:

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

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

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

     1、defer 函數(shù)調(diào)用的執(zhí)行時機是外層函數(shù)設(shè)置返回值之后, 并且在即將返回之前

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

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

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

當進行賦值操作 "r = 0" 后, 才調(diào)用 defer 函數(shù), 最后才是返回語句.

因此上面的代碼等效于:

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))
}

如果我們已經(jīng)理解了上面所說的內(nèi)容的話, 那么 triple 函數(shù)就很好理解了, 它實際上是:

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 函數(shù)中, 我們?yōu)榱吮苊飧倯B(tài)條件的出現(xiàn), 而使用了 Mutex 進行加鎖. 而在進行并發(fā)編程時, 加鎖了卻忘記(或某種情況下 unlock 沒有被執(zhí)行), 往往會造成災(zāi)難性的后果. 為了在任意情況下, 都要保證在加鎖操作后, 都進行對應(yīng)的解鎖操作, 我們可以使用 defer 調(diào)用解鎖操作.

總結(jié)

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