Go中defer使用场景及注意事项

wx_DdQG9

目录

1. 简介

1.1 使用场景1.2 注意事项

2. defer 数据结构3. 执行机制

3.1 栈上分配3.2 开放编码

4. 参考

1. 简介

defer 会在当前函数返回前执行传入的函数，它会经常被用于关闭文件描述符、关闭数据库连接以及解锁资源。
理解这句话主要在三个方面：

当前函数返回前执行，当然函数可能没有返回值传入的函数，即 defer 关键值后面跟的是一个函数，包括普通函数如（fmt.Println）, 也可以是匿名函数 func()

1.1 使用场景

使用 defer 的最常见场景是在函数调用结束后完成一些收尾工作，例如在 defer 中回滚数据库的事务：

1. func createPost(db *gorm.DB) error {
2.     tx := db.Begin()
3.     // 用来回滚数据库事件
4.     defer tx.Rollback()
6.     if err := tx.Create(&Post{Author: "Draveness"}).Error; err != nil {
7.         return err
8.     }
10.     return tx.Commit().Error
11. }

复制代码

在使用数据库事务时，我们可以使用上面的代码在创建事务后就立刻调用 Rollback 保证事务一定会回滚。哪怕事务真的执行成功了，那么调用 tx.Commit() 之后再执行 tx.Rollback() 也不会影响已经提交的事务。

1.2 注意事项

使用defer时会遇到两个常见问题，这里会介绍具体的场景并分析这两个现象背后的设计原理：
defer 关键字的调用时机以及多次调用 defer 时执行顺序是如何确定的defer 关键字使用传值的方式传递参数时会进行预计算，导致不符合预期的结果
作用域
向 defer 关键字传入的函数会在函数返回之前运行。
假设我们在 for 循环中多次调用 defer 关键字：

1. package main
3. import "fmt"
5. func main() {
6.         for i := 0; i < 5; i++ {
7.             // FILO, 先进后出, 先出现的关键字defer会被压入栈底，会最后取出执行
8.                 defer fmt.Println(i)
9.         }
10. }

复制代码

#运行
$ go run main.go
4
3
2
1
0

运行上述代码会倒序执行传入 defer 关键字的所有表达式，因为最后一次调用 defer 时传入了 fmt.Println(4)，所以这段代码会优先打印 4。我们可以通过下面这个简单例子强化对 defer 执行时机的理解：

1. package main
3. import "fmt"
5. func main() {
6.     // 代码块
7.         {
8.                 defer fmt.Println("defer runs")
9.                 fmt.Println("block ends")
10.         }
12.         fmt.Println("main ends")
13. }

复制代码

# 输出
$ go run main.go
block ends
main ends
defer runs

从上述代码的输出我们会发现，defer 传入的函数不是在退出代码块的作用域时执行的，它只会在当前函数和方法返回之前被调用。
预计算参数
Go 语言中所有的函数调用都是传值的.
虽然 defer 是关键字，但是也继承了这个特性。假设我们想要计算 main 函数运行的时间，可能会写出以下的代码：

1. package main
3. import (
4.         "fmt"
5.         "time"
6. )
8. func main() {
9.         startedAt := time.Now()
10.         // 这里误以为：startedAt是在time.Sleep之后才会将参数传递给defer所在语句的函数中
11.         defer fmt.Println(time.Since(startedAt))
13.         time.Sleep(time.Second)
14. }

复制代码

# 输出
$ go run main.go
0s

上述代码的运行结果并不符合我们的预期，这个现象背后的原因是什么呢？
经过分析(或者使用debug方式)，我们会发现：
调用 defer 关键字会立刻拷贝函数中引用的外部参数
所以 time.Since(startedAt) 的结果不是在 main 函数退出之前计算的，而是在 defer 关键字调用时计算的，最终导致上述代码输出 0s。
想要解决这个问题的方法非常简单，我们只需要向 defer 关键字传入匿名函数：

1. package main
3. import (
4.         "fmt"
5.         "time"
6. )
8. func main() {
9.         startedAt := time.Now()
10.     // 使用匿名函数，传递的是函数的指针
11.         defer func() {
12.                 fmt.Println(time.Since(startedAt))
13.         }()
15.         time.Sleep(time.Second)
16. }

复制代码

#输出
$ go run main.go
$ 1.0056135s

2. defer 数据结构

defer 关键字在 Go 语言源代码中对应的数据结构：

1. type _defer struct {
2.         siz       int32
3.         started   bool
4.         openDefer bool
5.         sp        uintptr
6.         pc        uintptr
7.         fn        *funcval
8.         _panic    *_panic
9.         link      *_defer
10. }

复制代码

简单介绍一下 runtime._defer 结构体中的几个字段：

siz 是参数和结果的内存大小；sp 和 pc 分别代表栈指针和调用方的程序计数器；fn 是 defer 关键字中传入的函数；_panic 是触发延迟调用的结构体，可能为空；openDefer 表示当前 defer 是否经过开放编码的优化；

除了上述的这些字段之外，runtime._defer 中还包含一些垃圾回收机制使用的字段, 这里不做过多的说明

3. 执行机制

堆分配、栈分配和开放编码是处理 defer 关键字的三种方法。

早期的 Go 语言会在堆上分配， 不过性能较差Go 语言在 1.13 中引入栈上分配的结构体，减少了 30% 的额外开销在1.14 中引入了基于开放编码的 defer，使得该关键字的额外开销可以忽略不计

堆上分配暂时不做过多的说明

3.1 栈上分配

在 1.13 中对 defer 关键字进行了优化，当该关键字在函数体中最多执行一次时，会将结构体分配到栈上并调用。
除了分配位置的不同，栈上分配和堆上分配的 runtime._defer 并没有本质的不同，而该方法可以适用于绝大多数的场景，与堆上分配的 runtime._defer 相比，该方法可以将 defer 关键字的额外开销降低 ~30%。

3.2 开放编码

在 1.14 中通过开放编码（Open Coded）实现 defer 关键字，该设计使用代码内联优化 defer 关键的额外开销并引入函数数据 funcdata 管理 panic 的调用3，该优化可以将 defer 的调用开销从 1.13 版本的~35ns 降低至 ~6ns 左右：
然而开放编码作为一种优化 defer 关键字的方法，它不是在所有的场景下都会开启的，开放编码只会在满足以下的条件时启用：

函数的 defer 数量小于或等于8个；函数的 defer 关键字不能再循环中执行函数的 return 语句 与 defer 语句个数的成绩小于或者等于15个。

4. 参考

https://draveness.me/golang/docs/part2-foundation/ch05-keyword/golang-defer/
到此这篇关于Go中defer使用注意事项的文章就介绍到这了,更多相关Go中defer使用内容请搜索咔叽论坛以前的文章或继续浏览下面的相关文章希望大家以后多多支持咔叽论坛！

原文地址：https://www.jb51.net/article/232339.htm