前言

大家都知道go語言的defer功能很強大，對于資源管理非常方便，但是如果沒用好，也會有陷阱哦。Go 語言中延遲函數(shù) defer 充當著 try...catch 的重任，使用起來也非常簡便，然而在實際應用中，很多 gopher 并沒有真正搞明白 defer、return、返回值、panic 之間的執(zhí)行順序，從而掉進坑中，今天我們就來揭開它的神秘面紗！話不多說了，來一起看看詳細的介紹吧。

先來運行下面兩段代碼：

A. 匿名返回值的情況

package main

import (
 "fmt"
)

func main() {
 fmt.Println("a return:", a()) // 打印結果為 a return: 0
}

func a() int {
 var i int
 defer func() {
  i++
  fmt.Println("a defer2:", i) // 打印結果為 a defer2: 2
 }()
 defer func() {
  i++
  fmt.Println("a defer1:", i) // 打印結果為 a defer1: 1
 }()
 return i
}

B. 有名返回值的情況

package main

import (
 "fmt"
)

func main() {
 fmt.Println("b return:", b()) // 打印結果為 b return: 2
}

func b() (i int) {
 defer func() {
  i++
  fmt.Println("b defer2:", i) // 打印結果為 b defer2: 2
 }()
 defer func() {
  i++
  fmt.Println("b defer1:", i) // 打印結果為 b defer1: 1
 }()
 return i // 或者直接 return 效果相同
}

先來假設出結論（這是正確結論），幫助大家理解原因：

• 多個 defer 的執(zhí)行順序為“后進先出/先進后出”；
• 所有函數(shù)在執(zhí)行 RET 返回指令之前，都會先檢查是否存在 defer 語句，若存在則先逆序調用 defer 語句進行收尾工作再退出返回；
• 匿名返回值是在 return 執(zhí)行時被聲明，有名返回值則是在函數(shù)聲明的同時被聲明，因此在 defer 語句中只能訪問有名返回值，而不能直接訪問匿名返回值；
• return 其實應該包含前后兩個步驟：第一步是給返回值賦值（若為有名返回值則直接賦值，若為匿名返回值則先聲明再賦值）；第二步是調用 RET 返回指令并傳入返回值，而 RET 則會檢查 defer 是否存在，若存在就先逆序插播 defer 語句，最后 RET 攜帶返回值退出函數(shù)；

因此，‍‍defer、return、返回值三者的執(zhí)行順序應該是：return最先給返回值賦值；接著 defer 開始執(zhí)行一些收尾工作；最后 RET 指令攜帶返回值退出函數(shù)。

如何解釋兩種結果的不同：

上面兩段代碼的返回結果之所以不同，其實從上面的結論中已經很好理解了。

• a()int 函數(shù)的返回值沒有被提前聲名，其值來自于其他變量的賦值，而 defer 中修改的也是其他變量（其實該 defer 根本無法直接訪問到返回值），因此函數(shù)退出時返回值并沒有被修改。
• b()(i int) 函數(shù)的返回值被提前聲名，這使得 defer 可以訪問該返回值，因此在 return 賦值返回值 i 之后，defer 調用返回值 i 并進行了修改，最后致使 return 調用 RET 退出函數(shù)后的返回值才會是 defer 修改過的值。

C. 下面我們再來看第三個例子，驗證上面的結論：

package main

import (
 "fmt"
)

func main() {
 c:=c()
 fmt.Println("c return:", *c, c) // 打印結果為 c return: 2 0xc082008340
}

func c() *int {
 var i int
 defer func() {
  i++
  fmt.Println("c defer2:", i, i) // 打印結果為 c defer2: 2 0xc082008340
 }()
 defer func() {
  i++
  fmt.Println("c defer1:", i, i) // 打印結果為 c defer1: 1 0xc082008340
 }()
 return i
}

雖然 c()int 的返回值沒有被提前聲明，但是由于 c()int 的返回值是指針變量，那么在 return 將變量 i 的地址賦給返回值后，defer 再次修改了 i 在內存中的實際值，因此 return 調用 RET 退出函數(shù)時返回值雖然依舊是原來的指針地址，但是其指向的內存實際值已經被成功修改了。

即，我們假設的結論是正確的！

D. 補充一條，defer聲明時會先計算確定參數(shù)的值，defer推遲執(zhí)行的僅是其函數(shù)體。

package main

import (
 "fmt"
 "time"
)

func main() {
 defer P(time.Now())
 time.Sleep(5e9)
 fmt.Println("main ", time.Now())
}

func P(t time.Time) {
 fmt.Println("defer", t)
 fmt.Println("P ", time.Now())
}

// 輸出結果：
// main 2017-08-01 14:59:47.547597041 +0800 CST
// defer 2017-08-01 14:59:42.545136374 +0800 CST
// P  2017-08-01 14:59:47.548833586 +0800 CST

E. defer 的作用域

1. defer 只對當前協(xié)程有效（main 可以看作是主協(xié)程）；
2. 當任意一條（主）協(xié)程發(fā)生 panic 時，會執(zhí)行當前協(xié)程中 panic 之前已聲明的 defer；
3. 在發(fā)生 panic 的（主）協(xié)程中，如果沒有一個 defer 調用 recover()進行恢復，則會在執(zhí)行完最后一個已聲明的 defer 后，引發(fā)整個進程崩潰；
4. 主動調用 os.Exit(int) 退出進程時，defer 將不再被執(zhí)行。

package main

import (
 "errors"
 "fmt"
 "time"
 // "os"
)

func main() {
 e := errors.New("error")
 fmt.Println(e)
 // （3）panic(e) // defer 不會執(zhí)行
 // （4）os.Exit(1) // defer 不會執(zhí)行
 defer fmt.Println("defer")
 // （1）go func() { panic(e) }() // 會導致 defer 不會執(zhí)行
 // （2）panic(e) // defer 會執(zhí)行
 time.Sleep(1e9)
 fmt.Println("over.")
 // （5）os.Exit(1) // defer 不會執(zhí)行
}

F. defer 表達式的調用順序是按照先進后出的方式執(zhí)行

defer 表達式會被放入一個類似于棧( stack )的結構，所以調用的順序是先進后出/后進先出的。

下面這段代碼輸出的結果是 4321 而不是 1234 。

package main

import (
 "fmt"
)

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

總結

以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作具有一定的參考學習價值，如果有疑問大家可以留言交流，謝謝大家對腳本之家的支持。