首页 » 脚本专栏 » Golang

Go中defer使用注意事项

Golang 2021-12-20

1. 简介

defer 会在当前函数返回前执行传入的函数,它会经常被用于关闭文件描述符、关闭数据库连接以及解锁资源。

理解这句话主要在三个方面:

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

1.1 使用场景

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

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

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

1.2 注意事项

使用defer时会遇到两个常见问题,这里会介绍具体的场景并分析这两个现象背后的设计原理:

  • defer 关键字的调用时机以及多次调用 defer 时执行顺序是如何确定的
  • defer 关键字使用传值的方式传递参数时会进行预计算,导致不符合预期的结果

作用域

向 defer 关键字传入的函数会在函数返回之前运行。

假设我们在 for 循环中多次调用 defer 关键字:

package main

import "fmt"

func main() {
	for i := 0; i < 5; i++ {
	    // FILO, 先进后出, 先出现的关键字defer会被压入栈底,会最后取出执行
		defer fmt.Println(i)
	}
} 
#运行
$ go run main.go
4
3
2
1
0 

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

package main

import "fmt"

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 

从上述代码的输出我们会发现,defer 传入的函数不是在退出代码块的作用域时执行的,它只会在当前函数和方法返回之前被调用。

预计算参数

Go 语言中所有的函数调用都是传值的.

虽然 defer 是关键字,但是也继承了这个特性。假设我们想要计算 main 函数运行的时间,可能会写出以下的代码:

package main

import (
	"fmt"
	"time"
)

func main() {
	startedAt := time.Now()
	// 这里误以为:startedAt是在time.Sleep之后才会将参数传递给defer所在语句的函数中
	defer fmt.Println(time.Since(startedAt))

	time.Sleep(time.Second)
} 
# 输出
$ go run main.go
0s 

上述代码的运行结果并不符合我们的预期,这个现象背后的原因是什么呢?

经过分析(或者使用debug方式),我们会发现:

  1. 调用 defer 关键字会立刻拷贝函数中引用的外部参数

所以 time.Since(startedAt) 的结果不是在 main 函数退出之前计算的,而是在 defer 关键字调用时计算的,最终导致上述代码输出 0s。

想要解决这个问题的方法非常简单,我们只需要向 defer 关键字传入匿名函数:

package main

import (
	"fmt"
	"time"
)

func main() {
	startedAt := time.Now()
    // 使用匿名函数,传递的是函数的指针
	defer func() {
		fmt.Println(time.Since(startedAt))
	}()

	time.Sleep(time.Second)
} 
#输出
$ go run main.go
$ 1.0056135s 

2. defer 数据结构

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

type _defer struct {
	siz       int32
	started   bool
	openDefer bool
	sp        uintptr
	pc        uintptr
	fn        *funcval
	_panic    *_panic
	link      *_defer
} 

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

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

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

3. 执行机制

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

  1. 早期的 Go 语言会在堆上分配, 不过性能较差
  2. Go 语言在 1.13 中引入栈上分配的结构体,减少了 30% 的额外开销
  3. 在 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 关键字的方法,它不是在所有的场景下都会开启的,开放编码只会在满足以下的条件时启用:

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

4. 参考

  1. https://draveness.me/golang/docs/part2-foundation/ch05-keyword/golang-defer/
?永远年轻,永远热泪盈眶?

上一篇:golan参数校验Validator下一篇:手把手教你导入Go语言第三方库
程序园_程序员的世界 Copyright © 2020- www.580doc.com. Some Rights Reserved.