golang中defer理解

defer简单使用

package main

import "fmt"

func main() {

    defer goodmorning()
    defer goodafternoon()
    fmt.Println("Hello world.")
    return
    defer goodnight()
    defer goodbye()
}

func goodmorning() {
    fmt.Println("GoodMorning")
}

func goodafternoon() {
    fmt.Println("GoodAfterNoon")
}

func goodnight() {
    fmt.Println("GoodNight")
}

func goodbye() {
    fmt.Println("Goodbye")
}

打印log如下：

Hello world.
GoodAfterNoon
GoodMorning

可以看出以下几个结论：
1. return 之后的语句，defer是不会打印出来的，这跟我们平时用的语法一样；
2. defer要打印的语句，是在return之前去调用；
3. 当函数中有多个defer，按先进后出的原则调用。

defer用于关闭文件

package main

import "fmt"
import "os"

func main() {

    f := createFile("/tmp/defer.txt")
    defer closeFile(f)
    writeFile(f)
}

func createFile(p string) *os.File {
    fmt.Println("creating")
    f, err := os.Create(p)
    if err != nil {
        panic(err)
    }
    return f
}

func writeFile(f *os.File) {
    fmt.Println("writing")
    fmt.Fprintln(f, "data")

}

func closeFile(f *os.File) {
    fmt.Println("closing")
    f.Close()

defer用于锁

func Divide(i int) error {
    mu.Lock()
    defer mu.Unlock()

    if i == 0 {
        return errors.New("Can't divide by zero!")
    }

    val /= i
    return nil
}

defer中的坑

package main

import (
    "fmt"
)

func main() {
    fmt.Println(f())
    fmt.Println(f1())
    fmt.Println(f2())
}

func f() (result int) {
    defer func() {
        result++
    }()
    return 0
}

func f1() (r int) {
    t := 5
    defer func() {
        t = t + 5
    }()
    return t
}

func f2() (r int) {
    defer func(r int) {
        r = r + 5
    }(r)
    return 1
}

要使用defer时不踩坑，最重要的一点就是要明白，return xxx这一条语句并不是一条原子指令!
函数返回的过程是这样的：先给返回值赋值，然后调用defer表达式，最后才是返回到调用函数中。
defer表达式可能会在设置函数返回值之后，在返回到调用函数之前，修改返回值，使最终的函数返回值与你想象的不一致。