defer

---

Go 语言的 defer 会在当前函数或者方法（不是main）返回之前执行函数。由于 defer 的延迟特性，defer 常用在函数调用结束之后清理相关的资源（数据库连接，file IO）

f, _ := os.Open(filename)
defer f.Close()

• defer函数里的变量需要在defer之前就要申明

执行顺序（类似栈，先进后执行）

func main() {
    for i := 0; i < 5; i++ {
        fmt.Print("HELLO\n")
        defer fmt.Println(i)
    }
}

$ go run main.go
HELLO
HELLO
HELLO
HELLO
HELLO
4
3
2
1
0

以function为结尾单位：

func main() {
    {
        defer fmt.Println("defer runs")
        fmt.Println("block ends")
    }
    fmt.Println("main ends")
}

$ go run main.go
block ends
main ends
defer runs

最后执行原则（先执行return func，然后再执行defer func）

func c() (i int) {
    i=0
    defer func() { i++ }()
    return i
}

用于打印执行时间（直接拷贝传入的参数，值传递）

func main() {
    startedAt := time.Now()
    defer fmt.Println(time.Since(startedAt))
    
    time.Sleep(time.Second)
}
$ go run main.go
0s

调用 defer 关键字会立刻对函数中引用的外部参数进行拷贝，所以 time.Since(startedAt) 的结果不是在 main 函数退出之前计算的，而是在 defer 关键字调用时计算的，最终导致上述代码输出 0s。

func main() {
    startedAt := time.Now()
    // 匿名函数 func(){}()
    defer func() { fmt.Println(time.Since(startedAt)) }()
    
    time.Sleep(time.Second)
}
$ go run main.go
1s

改成传入函数指针，解决问题。

---

defer+匿名函数+recover 作为Go语言的 try...catch

package main
import (
    "fmt"
)
func foo(){
    defer func(){
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    var bar = []int{1}
    fmt.Println(bar[1])
}
func main(){
    foo()
    fmt.Println("exit")
}

---

调度原理

goroutine 结构体中会保存 defer 调用链，函数 return 时候会判断 pc 和 goroutine defer 链中的 pc 和当前 pc 关系，如果符合条件就执行 defer 结构体中保存的函数指针，参数也是通过 defer 结构体保存的传递过去的。

所以 defer 函数传递的是值传递。

• panic一般不会阻断defer的执行

---

defer 与 return 与 返回值 的执行关系

1. 匿名返回值（defer不能修改i）（return的时候申明）

package main
import (
    "fmt"
)
func main() {
    fmt.Println("a return:", a()) // 打印结果为 a return: 0
}
func a() int {
    var i int
    defer func() {
        i++
        fmt.Println("a defer2:", i) // 打印结果为 a defer2: 2
    }()
    defer func() {
        i++
        fmt.Println("a defer1:", i) // 打印结果为 a defer1: 1
    }()
    return i
}

2. 有名返回值（defer可以修改i）（函数申明的同时申明变量）

package main
import (
    "fmt"
)
func main() {
    fmt.Println("b return:", b()) // 打印结果为 b return: 2
}
func b() (i int) {
    defer func() {
        i++
        fmt.Println("b defer2:", i) // 打印结果为 b defer2: 2
    }()
    defer func() {
        i++
        fmt.Println("b defer1:", i) // 打印结果为 b defer1: 1
    }()
    return i // 或者直接 return 效果相同
}

• 结论

1. 多个defer的执行顺序为“后进先出”；
2. 所有函数在执行RET返回指令之前，都会先检查是否存在defer语句，若存在则先逆序（后进先出）调用defer语句进行收尾工作再退出返回；
3. 匿名返回值是在return执行时被声明，有名返回值则是在函数声明的同时被声明，因此在defer语句中只能访问有名返回值，而不能直接访问匿名返回值；
4. return其实应该包含前后两个步骤：第一步是给返回值赋值（若为有名返回值则直接赋值，若为匿名返回值则先声明再赋值）；第二步是调用RET返回指令并传入返回值，而RET则会检查defer是否存在，若存在就先逆序插播defer语句，最后RET携带返回值退出函数；

‍‍因此，‍‍defer、return、返回值三者的执行顺序应该是：return最先给返回值赋值；接着defer开始执行一些收尾工作；最后RET指令携带返回值退出函数。

---

package main
import (
    "fmt"
)
func main() {
    c:=c()
    fmt.Println("c return:", *c, c) // 打印结果为 c return: 2 0xc082008340
}
func c() *int {
    var i int
    defer func() {
        i++
        fmt.Println("c defer2:", i, &i) // 打印结果为 c defer2: 2 0xc082008340
    }()
    defer func() {
        i++
        fmt.Println("c defer1:", i, &i) // 打印结果为 c defer1: 1 0xc082008340
    }()
    return &i
}

---

defer 不影响函数参数的执行

defer声明时会先计算确定参数的值，defer推迟执行的仅是其函数体。

package main
import (
    "fmt"
    "time"
)
func main() {
    defer P(time.Now())
    time.Sleep(5e9)
    fmt.Println("1", time.Now())
}
func P(t time.Time) {
    fmt.Println("2", t)
    fmt.Println("3", time.Now())
}

// 输出结果：
// 1 2017-08-01 14:59:47.547597041 +0800 CST
// 2 2017-08-01 14:59:42.545136374 +0800 CST
// 3 2017-08-01 14:59:47.548833586 +0800 CST