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

1. 简介

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

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

当前函数
返回前执行，当然函数可能没有返回值
传入的函数，即 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方式)，我们会发现：

调用 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

									}