快捷導(dǎo)航

聊聊golang中多個defer的執(zhí)行順序

更新時間：2021年05月08日 14:25:04 作者：robin912

這篇文章主要介紹了golang中多個defer的執(zhí)行順序，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧

golang 中多個 defer 的執(zhí)行順序

引用 Ture Go 中的一個示例:

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

程序執(zhí)行結(jié)果為:

counting

done

9

8

7

6

5

4

3

2

1

0

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

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

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

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

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

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

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

如上代碼，壓入棧的是一個函數(shù)地址，函數(shù)執(zhí)行完后，執(zhí)行i++,會改變返回值，函數(shù)返回值為 2。

從上面的通過defer修改返回值，defer也可以用于控制恢復(fù)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)
}

執(zhí)行結(jié)果為:

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.

補(bǔ)充：Golang中defer的三個實(shí)戰(zhàn)要點(diǎn)

前言

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

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

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

1.defer的生效順序

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

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

正文

1.defer的生效順序

先說結(jié)論：defer的執(zhí)行順序是倒序執(zhí)行（同入棧先進(jìn)后出）

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

執(zhí)行后打印出：

我先出來

我后出來

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

先說結(jié)論：return最先執(zhí)行->return負(fù)責(zé)將結(jié)果寫入返回值中->接著defer開始執(zhí)行一些收尾工作->最后函數(shù)攜帶當(dāng)前返回值退出

返回值的表達(dá)方式，我們知道根據(jù)是否提前聲明有兩種方式：一種是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的時候已經(jīng)先將返回值給定義下來了，就是0，由于i是在函數(shù)內(nèi)部聲明所以即使在defer中進(jìn)行了++操作，也不會影響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執(zhí)行后進(jìn)行了兩次++，將i的值變?yōu)?，待defer執(zhí)行完后，函數(shù)將i值進(jìn)行了返回。

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

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

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

以上為個人經(jīng)驗(yàn)，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。

您可能感興趣的文章: