[系列] Go 使用 defer 函數要注意的幾個點

時間 2019-12-23

標籤系列使用 defer 函數注意幾個简体版

原文原文鏈接

概述

defer 函數你們確定都用過，它在聲明時不會馬上去執行，而是在函數 return 後去執行的。api

它的主要應用場景有異常處理、記錄日誌、清理數據、釋放資源等等。閉包

這篇文章不是分享 defer 的應用場景，而是分享使用 defer 須要注意的點。tcp

我們先從一道題開始，一塊兒來感覺下 ...函數

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func main() {
    x := 1
    y := 2
    defer calc("A", x, calc("B", x, y))
    x = 3
    defer calc("C", x, calc("D", x, y))
    y = 4
}

輸出什麼？日誌

...code

接下來，先容我分享幾個小例子，再進行做答。協程

執行順序

func main() {

    defer fmt.Println("1")
    defer fmt.Println("2")
    defer fmt.Println("3")

    fmt.Println("main")
}

輸出：中間件

main
3
2
1

結論：defer 函數定義的順序與實際執的行順序是相反的，也就是最早聲明的最後才執行。blog

閉包

func main() {

    var a = 1
    var b = 2

    defer fmt.Println(a + b)

    a = 2

    fmt.Println("main")
}

輸出：資源

main
3

稍微修改一下，再看看：

func main() {
    var a = 1
    var b = 2

    defer func() {
        fmt.Println(a + b)
    }()

    a = 2

    fmt.Println("main")
}

輸出：

main
4

結論：閉包獲取變量至關於引用傳遞，而非值傳遞。

稍微再修改一下，再看看：

func main() {
    var a = 1
    var b = 2

    defer func(a int, b int) {
        fmt.Println(a + b)
    }(a, b)

    a = 2

    fmt.Println("main")
}

輸出：

main
3

結論：傳參是值複製。

還能夠理解爲：defer 調用的函數，參數的值在 defer 定義時就肯定了，看下代碼

defer fmt.Println(a + b)，在這時，參數的值已經肯定了。

而 defer 函數內部所使用的變量的值須要在這個函數運行時才肯定，看下代碼

defer func() { fmt.Println(a + b) }()，a 和 b 的值在函數運行時，才能肯定。

Return

一

func t1() int {
    a := 1
    defer func() {
        a++
    }()
    return a
}

輸出：1

二

func t2() (a int) {
    defer func() {
        a++
    }()
    return 1
}

輸出：2

三

func t3() (b int) {
    a := 1
    defer func() {
        a++
    }()
    return 1
}

輸出：1

四

func t4() (a int) {
    defer func(a int) {
        a++
    }(a)
    return 1
}

輸出：1

結論：return 不是原子操做。

os.Exit

func main() {
    defer fmt.Println("1")
    fmt.Println("main")
    os.Exit(0)
}

輸出：main

結論：當os.Exit()方法退出程序時，defer不會被執行。

不一樣協程

func main() {
    GoA()
    time.Sleep(1 * time.Second)
    fmt.Println("main")
}

func GoA() {
    defer (func(){
        if err := recover(); err != nil {
            fmt.Println("panic:" + fmt.Sprintf("%s", err))
        }
    })()

    go GoB()
}

func GoB() {
    panic("error")
}

GoB() panic 捕獲不到。

結論：defer 只對當前協程有效。

這個問題怎麼解？我們下回再說。

接下來，我們分析下文章開頭的問題吧。

答案解析

先列出答案：

其實上面那道題，能夠拆解爲：

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}

func main() {
    x := 1
    y := 2
    tmp1 := calc("B", x, y)
    defer calc("A", x, tmp1)
    x = 3
    tmp2 := calc("D", x, y)
    defer calc("C", x, tmp2)
    y = 4
}

因此順序就是：B D C A。

執行到 tmp1 時，輸出：B 1 2 3。

執行到 tmp2 時，輸出：D 3 2 5。

根據 defer 執行順序原則，先聲明的後執行，因此下一個該執行 C 了。

又由於傳參是值賦值，因此在 A 的時候，沒法用到 x = 3 和 y = 4，在 C 的時候，沒法用到 y = 4。

執行到 C 時，輸出：C 3 5 8

執行到 A 時，輸出：A 1 3 4

到這，基本上 defer 就清楚了，你們能夠根據本身的理解去記憶。