介绍

《Go程序设计语言》
你只需要在调用普通函数或方法前加上关键字defer，就完成了defer所需要的语法。
当执行到该条语句时，函数和参数表达式得到计算，但直到包含该defer语句的函数执行完毕时，defer后的函数才会被执行，不论包含defer语句的函数是通过return正常结束，还是由于panic导致的异常结束。你可以在一个函数中执行多条defer语句，它们的执行顺序与声明顺序相反。

《Go入门指南》
允许我们推迟到函数返回之前（或者任意位置执行 return 语句之后）一刻才执行某个语句或者函数（为什么要在返回之后才执行这些语句？因为 return 语句同样可以包含一些操作，而不是单纯地返回某个值）

类似于其它面向对象语言中的 finall 语句，一般用于释放某些已分配的资源。

规则

  1. defer声明时，其后面的函数参数会被实时解析
  2. defer 执行顺序为FILO，栈操作
  3. defer 可以读取函数的有名返回值

规则一

defer 声明时，其后面的函数参数会被实时解析

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var i int = 1
  8.     defer fmt.Println("result1 ==> ", func() int {
  9.         return i * 2          // 函数参数被实时解析
  10.     }())
  12.     i++
  13.     fmt.Println("i: ", i)
  15.     defer func() {
  16.         fmt.Println("relult2 ==> ", i*2)   // 函数体为引用
  17.     }()
  18.     i++
  19.     fmt.Println("i: ", i)
  20. }

输出

  1. D:\projects\gocode\studylib>go run d:\projects\gocode\studylib\deferdemo\main.go
  2. i:  2
  3. i:  3
  4. relult2 ==>  6
  5. result1 ==>  2

规则二

defer 执行顺序为FILO，栈操作

  2. func main() {
  3.     defer fmt.Print("!!!")
  4.     defer fmt.Print("world")
  5.     defer fmt.Print("hello")
  6. }

规则三

defer 可以读取函数的有名返回值

  2. func fun1() (i int) {
  3.     defer func() {
  4.         i += 10   // return 之前，调用 i+=10
  5.     }()
  7.     return 0    // 返回 i = 0
  8. }
  10. func main() {
  11.     fmt.Println("result2 ==>", fun1())
  12. }

输出

  1. D:\projects\gocode\studylib>go run d:\projects\gocode\studylib\deferdemo\main.go
  2. result2 ==> 10

return设计

defer - 图1go 语言中 return 返回流程： return语句设计为不是原子操作，

  • 最先是所有返回值，在进入函数时都会初始化为其类型的零值（注意： 是有名返回值）
  • 执行 defer
  • 最后 return defer - 图2

    列举以下

情况一： 有名返回值

  2. func fun1() (i int) {
  3.     defer func() {
  4.         i++
  5.         fmt.Println("func1 defer2:", i)
  6.     }()
  8.     defer func() {
  9.         i++
  10.         fmt.Println("func1 defer1:", i)
  11.     }()
  12.     return 0
  13. }
  16. func main() {
  17.     fmt.Println("=========================================")
  18.     // fmt.Println("fun1 return", fun1())
  20.     fmt.Println("=========================================")
  21.     fmt.Println("fun2 return", fun2())
  23.     fmt.Println("=========================================")
  24.     // fmt.Println("fun3 return", fun3())
  26.     fmt.Println("=========================================")
  27.     // fmt.Println("fun4 return", fun4())
  29.     fmt.Println("=========================================")
  30.     // n, _ := funcReturn("go")
  31.     // fmt.Println(n)
  32. }

情况二：无名返回值

  2. func fun2() int {
  3.     var i int // i= 0
  4.     defer func() {
  5.         i++
  6.         fmt.Println("func2 defer2: ", i)   
  7.     }()   // 实际的调用推迟到包含 defer 语句的函数结束后才执行。
  9.     defer func() {
  10.         i++
  11.         fmt.Println("func2 defer1: ", i)
  12.     }()  // 实际的调用推迟到包含 defer 语句的函数结束后才执行。
  13.     return i
  14. }
  17. func main() {
  18.     fmt.Println("=========================================")
  19.     // fmt.Println("fun1 return", fun1())
  21.     fmt.Println("=========================================")
  22.     fmt.Println("fun2 return", fun2())
  24.     fmt.Println("=========================================")
  25.     // fmt.Println("fun3 return", fun3())
  27.     fmt.Println("=========================================")
  28.     // fmt.Println("fun4 return", fun4())
  30.     fmt.Println("=========================================")
  31.     // n, _ := funcReturn("go")
  32.     // fmt.Println(n)
  33. }

输出结果

  1. func2 defer1:  1
  2. func2 defer2:  2
  3. fun2 return 0

情况三：非原子操作

  1. func f0() (r int) {
  2.     t := 5
  3.     defer func() {
  4.         fmt.Printf("f0 defer t is :%d\n", t) //5
  5.         fmt.Printf("f0 defer r is :%d\n", r) //5
  6.         t = t + 5
  7.         fmt.Printf("f0 defer r is :%d\n", r) //5
  8.     }()
  9.     return t
  11.     // 1. r = t   (t =5)
  12.     // 5
  13.     // 5
  14.     // 5
  15.     // return
  16. }

这里需要注意的是,return xxx语句并不是一条原子指令，defer 被插入到了 赋值 与 ret 之间。因此 return t应该被拆解程两部分，r = t 和 return。

情况四： 一个延迟调用可以修改包含此延迟调用的最内层函数的返回值

  1. package main
  2. import "fmt"
  3. func Triple(n int) (r int) {
  4.     defer func() {
  5.         r += n // 修改返回值
  6.     }()
  7.     return n + n // <=> r = n + n; return
  8. }
  9. func main() {
  10.     fmt.Println(Triple(5)) // 15
  11. }

估值

一个协程调用或者延迟调用的实参是在此调用发生时被估值的。更具体地说，

  • 对于一个延迟函数调用，它的实参是在此调用被推入延迟调用堆栈的时候被估值的。
  • 对于一个协程调用，它的实参是在此协程被创建的时候估值的。
  • 一个匿名函数体内的表达式是在此函数被执行的时候才会被逐个估值的，不管此函数是被普通调用还是延迟/协程调用。

一个例子：

  1. package main
  2. import "fmt"
  3. func main() {
  4.     func() {
  5.         for i := 0; i < 3; i++ {
  6.             defer fmt.Println("a:", i)
  7.         }
  8.     }()
  9.     fmt.Println()
  10.     func() {
  11.         for i := 0; i < 3; i++ {
  12.             defer func() {
  13.                 fmt.Println("b:", i)
  14.             }()
  15.         }
  16.     }()
  17. }

输出

  1. D:\projects\gocode\studylib\deferdemo>go run main.go func1.go func2.go
  2. a: 2
  3. a: 1
  4. a: 0
  6. b: 3
  7. b: 3
  8. b: 3

第一个匿名函数中的循环打印出2、1和0这个序列，但是第二个匿名函数中的循环打印出三个3。因为第一个循环中的i是在fmt.Println函数被延迟调用的时候估的值，而第二个循环中的i是在第二个匿名函数调用的退出阶段估的值（此时循环变量i的值已经变为3）。 我们可以对第二个循环略加修改（使用两种方法），使得它和第一个循环打印出相同的结果。

参考

https://gocn.vip/topics/8880