Golang 的defer執行規則說明

Posted on by

defer介紹

defer是golang的一個特色功能，被稱為“延遲調用函數”。當外部函數返回後執行defer。類似於其他語言的 try… catch … finally… 中的finally，當然差別還是明顯的。

在使用defer之前我們應該多瞭解defer的特性，這樣才能避免使用上的誤區。

1. 最簡單的defer

func test(){
    defer func(){ fmt.Println("defer") }()
    //todo
    //...
    return
    //defer執行時機
}

我們可以稍微改動一下上述代碼再次確認defer的執行時機。

func main() {
    fmt.Println(test())
}
func test() (i int) {
    defer func() { i++ }()
    defer func() { fmt.Println(i) }()
    //todo
    //...
    fmt.Println(0)
    return 1
    //defer執行時機
}

output:

0

1

2

從上面示例可以發現defer執行是在return之後，且按照defer聲明的先進後出順序執行。以下是真實場景中比較常見的用法。

釋放占用的資源

func test() error {
    file, err := os.Open("path")
    if err != nil {
        return err
    }
    //放在判斷err狀態之後
    defer file.Close()
    //todo
    //...
    return nil
    //defer執行時機
}

捕捉處理異常

func test2() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    file, err := os.Open("path")
    if err != nil {
        panic(err)
    }
    defer file.Close()
    //todo
    //...
    return
    //defer執行時機
}

輸出日志 等收尾工作

func test3() {
    t1 := time.Now()
    defer func() {
        fmt.Printf("耗時: %f s", time.Now().Sub(t1).Seconds())
    }()
    //todo
    //...
    return
    //defer執行時機
}

2. 復雜的defer

當我們已經深深記住defer的執行時機並打算翻過這一頁時，事情的發展又開始偏離初始。請看如下代碼

func test() {
    i := 0
    defer fmt.Println(i)                       //輸出 0
    defer func(x int) { fmt.Println(x) }(i)    //輸出 0
    defer func(x *int) { fmt.Println(*x) }(&i) //輸出 1
    defer func() { fmt.Println(i) }()          //輸出 1
    i++
    //todo
    //...
    fmt.Println(i) //輸出 1
    return   
}

output:

1

1

1

0 // 值未修改

0 // 值未修改

通常認為defer就像真的被挪到瞭return之後。

但defer的本質依然是函數調用。當執行到defer定義時，首先會對參數進行求值，然後參數被壓入函數調用棧，此時不會進入defer函數體，而是直到函數返回時才調用defer函數體。

參數被壓入函數調用棧時，如果參數是值類型，那麼將復制值，如果參數是指針，那麼將復制指針而不是復制指針指向的值。

defer函數體內的變量是在return後執行因此不受影響。

因此我們在使用defer時一定要明確函數的參數類型（如果有的話），其次要明確defer函數體內的變量引用是否正確。

以下是常見錯誤

func test4() error {
    f, err := os.Open("A.txt")
    if err != nil {
        return err
    }
    defer func() { f.Close() }()//錯誤: 關閉是B文件,f引用被重新賦值
    f, err = os.Open("B.txt")
    if err != nil {
        return err
    }
    defer func() { f.Close() }() //關閉是B文件
    list := []int{1, 2}
    for _, i := range list {
        defer fmt.Println(i) //輸出 2 1 //i為值類型參數被復制
        defer func() { fmt.Println(i) }() //錯誤: 輸出 2 2 //函數體內對i引用,留最終值
    }
    return nil
}

3. 更復雜點的defer

且看如下代碼

type Test struct {
    name string
}
func (this *Test) Point() { // this  為指針
    fmt.Println(this.name)
}
func (this  Test) Value() { //this  為值類型 
    fmt.Println(this.name)
}
func test5() {
    ts := []Test{{"a"}, {"b"}, {"c"}}
    for _, t := range ts {
        defer t.Point() //輸出 c c c
        defer t.Value() //輸出 c b a
    }
}

看似相同的代碼卻輸出瞭完全不同的結果。要理解這種差別還是得從調用函數的本質來說。golang對struct 的方法調用是這樣的

defer func (this Type, para) result

struct 的方法在定義時this 采用的值類型還是指針決定defer在調用時首個參數(隱藏)的復制的不同。

上述代碼中Point方法定義時使用瞭指針作為this，因此輸出是for循環最終賦值的t引用。

Value方法定義時使用值類型作為this，因此輸出是for循環執行的每步復制後的t。

最終隻有理解瞭以上出現的問題，到此defer所帶來困擾才能遠離我們。

補充：Golang中defer的三個實戰要點

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

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

本文將從通過代碼的方式來說明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。如有錯誤或未考慮完全的地方，望不吝賜教。

推薦閱讀：