Go 延迟函数 defer 详解

Go 延迟函数 defer 详解

Go 语言中延迟函数 defer 充当着 try...catch 的重任，使用起来也非常简便，然而在实际应用中，很多 gopher 并没有真正搞明白 defer、return、返回值、panic 之间的执行顺序，从而掉进坑中，今天我们就来揭开它的神秘面纱！

先来运行下面两段代码：

A. 匿名返回值的情况

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
}

B. 有名返回值的情况

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 指令携带返回值退出函数。

如何解释两种结果的不同：

上面两段代码的返回结果之所以不同，其实从上面的结论中已经很好理解了。

• a()int 函数的返回值没有被提前声名，其值来自于其他变量的赋值，而 defer 中修改的也是其他变量（其实该 defer 根本无法直接访问到返回值），因此函数退出时返回值并没有被修改。

• b()(i int) 函数的返回值被提前声名，这使得 defer 可以访问该返回值，因此在 return 赋值返回值 i 之后，defer 调用返回值 i 并进行了修改，最后致使 return 调用 RET 退出函数后的返回值才会是 defer 修改过的值。

  C. 下面我们再来看第三个例子，验证上面的结论：

  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
  }

  虽然 c()int 的返回值没有被提前声明，但是由于 c()int 的返回值是指针变量，那么在 return 将变量 i 的地址赋给返回值后，defer 再次修改了 i 在内存中的实际值，因此 return 调用 RET 退出函数时返回值虽然依旧是原来的指针地址，但是其指向的内存实际值已经被成功修改了。

  即，我们假设的结论是正确的！

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

  package main
  
  import (
      "fmt"
      "time"
  )
  
  func main() {
      defer P(time.Now())
      time.Sleep(5e9)
      fmt.Println("main ", time.Now())
  }
  
  func P(t time.Time) {
      fmt.Println("defer", t)
      fmt.Println("P    ", time.Now())
  }
  
  // 输出结果：
  // main  2017-08-01 14:59:47.547597041 +0800 CST
  // defer 2017-08-01 14:59:42.545136374 +0800 CST
  // P     2017-08-01 14:59:47.548833586 +0800 CST
  

  E. defer 的作用域

  1. defer 只对当前协程有效（main 可以看作是主协程）；

  2. 当任意一条（主）协程发生 panic 时，会执行当前协程中 panic 之前已声明的 defer；

  3. 在发生 panic 的（主）协程中，如果没有一个 defer 调用 recover()进行恢复，则会在执行完最后一个已声明的 defer 后，引发整个进程崩溃；

  4. 主动调用 os.Exit(int) 退出进程时，defer 将不再被执行。

  package main
  
  import (
      "errors"
      "fmt"
      "time"
      // "os"
  )
  
  func main() {
      e := errors.New("error")
      fmt.Println(e)
      // （3）panic(e) // defer 不会执行
      // （4）os.Exit(1) // defer 不会执行
      defer fmt.Println("defer")
      // （1）go func() { panic(e) }() // 会导致 defer 不会执行
      // （2）panic(e) // defer 会执行
      time.Sleep(1e9)
      fmt.Println("over.")
      // （5）os.Exit(1) // defer 不会执行
  }

  F. defer 表达式的调用顺序是按照先进后出的方式执行

  defer 表达式会被放入一个类似于栈( stack )的结构，所以调用的顺序是先进后出/后进先出的。

  下面这段代码输出的结果是 4321 而不是 1234 。

  package main
  
  import (
      "fmt"
  )
  
  func main() {
      defer fmt.Print(1)
      defer fmt.Print(2)
      defer fmt.Print(3)
      defer fmt.Print(4)
  }