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 与 返回值 的执行关系
- 匿名返回值（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
}
- 有名返回值（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 效果相同
}
- 结论
- 多个defer的执行顺序为“后进先出”；
- 所有函数在执行RET返回指令之前，都会先检查是否存在defer语句，若存在则先逆序（后进先出）调用defer语句进行收尾工作再退出返回；
- 匿名返回值是在return执行时被声明，有名返回值则是在函数声明的同时被声明，因此在defer语句中只能访问有名返回值，而不能直接访问匿名返回值；
- 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
