defer延迟函数怎么在Go语言中使用

这篇文章给大家介绍defer延迟函数怎么在Go语言中使用，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。

创新互联公司主要从事网站设计、成都做网站、网页设计、企业做网站、公司建网站等业务。立足成都服务佳县,十余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108

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 效果相同
}

先来假设出结论（这是正确结论），帮助大家理解原因：

• 多个 defer 的执行顺序为“后进先出/先进后出”；

• 所有函数在执行 RET 返回指令之前，都会先检查是否存在 defer 语句，若存在则先逆序调用 defer 语句进行收尾工作再退出返回；

• 匿名返回值是在 return 执行时被声明，有名返回值则是在函数声明的同时被声明，因此在 defer 语句中只能访问有名返回值，而不能直接访问匿名返回值；

• 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)
}

关于defer延迟函数怎么在Go语言中使用就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。