聊聊golang中多個defer的執行順序

Posted on by

golang 中多個 defer 的執行順序

引用 Ture Go 中的一個示例:

package main
import "fmt"
func main() {
    fmt.Println("counting")
    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }
    fmt.Println("done")
}

程序執行結果為:

counting

done

9

8

7

6

5

4

3

2

1

0

從結果可以看出,defer 的執行可以看做是一個 FILO(First In Last Out) 棧。

在編寫程序時，如果遇到下面的執行流程，id1 先獲取資源，然後 id2 通過 id1 獲取，而 id2 的釋放 Close 必須要在 id1 之前，如下:

func fun() {
    id1 := Open()
    ...
    id2 := id1.Open()
    ...
    id2.Close()
    id1.Close()
}

如果使用defer，其執行順序和上面完全相同的，所以我們通常在 Open 打開資源後，立即使用 defer Close，不會引起釋放順序問題。

func fun() {
    id1 := Open()
    defer id1.Close()
    ...
    id2 := id1.Open()
    id2.Close()
    ...
}

defer 壓入棧的是值，如果為函數，則可以修改變量值

func c() (i int) {
    defer func() { i++ }()
    return 1
}

如上代碼，壓入棧的是一個函數地址，函數執行完後，執行i++,會改變返回值，函數返回值為 2。

從上面的通過defer修改返回值，defer也可以用於控制恢復panic斷言。

package main
import "fmt"
func main() {
    f()
    fmt.Println("Returned normally from f.")
}
func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
    fmt.Println("Calling g.")
    g(0)
    fmt.Println("Returned normally from g.")
}
func g(i int) {
    if i > 3 {
        fmt.Println("Panicking!")
        panic(fmt.Sprintf("%v", i))
    }
    defer fmt.Println("Defer in g", i)
    fmt.Println("Printing in g", i)
    g(i + 1)
}

執行結果為:

Calling g.

Printing in g 0

Printing in g 1

Printing in g 2

Printing in g 3

Panicking!

Defer in g 3

Defer in g 2

Defer in g 1

Defer in g 0

Recovered in f 4

Returned normally from f.

補充：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。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：