理解Go语言延迟执行语句defer关键字

Go语言的 defer 语句会将其后面跟随的语句进行延迟处理，在 defer 归属的函数即将返回时，将延迟处理的语句按 defer 的逆序进行执行，也就是说，先被 defer 的语句最后被执行，最后被 defer 的语句，最先被执行。

关键字 defer 的用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块，它一般用于释放某些已分配的资源，典型的例子就是对一个互斥解锁，或者关闭一个文件。

常见使用

首先要介绍的就是使用 defer 最常见的场景，也就是在 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
}
1
2
3
4
5
6
7
8
9
10

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

多个延迟执行语句的处理顺序

当有多个 defer 行为被注册时，它们会以逆序执行（类似栈，即后进先出），下面的代码是将一系列的数值打印语句按顺序延迟处理，如下所示：

package main
import (
    "fmt"
)
func main() {
    fmt.Println("defer begin")
    // 将defer放入延迟调用栈
    defer fmt.Println(1)
    defer fmt.Println(2)
    // 最后一个放入, 位于栈顶, 最先调用
    defer fmt.Println(3)
    fmt.Println("defer end")
}
1
2
3
4
5
6
7
8
9
10
11
12
13

代码输出如下：

defer begin
defer end
3
2
1
1
2
3
4
5

通过这段代码的运行结果很容易总结出：（1）代码的延迟顺序与最终的执行顺序是反向的。（2）延迟调用是在 defer 所在函数结束时进行，函数结束可以是正常返回时，也可以是发生宕机时。

使用延迟执行语句在函数退出时释放资源

处理业务或逻辑中涉及成对的操作是一件比较烦琐的事情，比如打开和关闭文件、接收请求和回复请求、加锁和解锁等。在这些操作中，最容易忽略的就是在每个函数退出处正确地释放和关闭资源。

defer 语句正好是在函数退出时执行的语句，所以使用 defer 能非常方便地处理资源释放问题。

使用延迟并发解锁

在下面的例子中会在函数中并发使用 map，为防止竞态问题，使用 sync.Mutex 进行加锁，参见下面代码：

var (
    // 一个演示用的映射
    // 实例化一个 map，键是 string 类型，值为 int
    valueByKey      = make(map[string]int)
    // 保证使用映射时的并发安全的互斥锁
    // map 默认不是并发安全的
    // 准备一个 sync.Mutex 互斥量保护 map 的访问
    valueByKeyGuard sync.Mutex
)
// 根据键读取值
// readValue() 函数给定一个键，从 map 中获得值后返回
// 该函数会在并发环境中使用，需要保证并发安全
func readValue(key string) int {
    // 使用互斥量对共享资源加锁
    valueByKeyGuard.Lock()
    // 从 map 中获取值
    v := valueByKey[key]
    // 使用互斥量对共享资源解锁
    valueByKeyGuard.Unlock()
    // 返回获取到的 map 值
    return v
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

使用 defer 语句对上面的语句进行简化，参考下面的代码：

func readValue(key string) int {
    valueByKeyGuard.Lock()
   
    // defer后面的语句不会马上调用, 而是延迟到函数结束时调用
    // 在互斥量加锁后，使用 defer 语句添加解锁
    // 该语句不会马上执行，而是等 readValue() 函数返回时才会被执行
    defer valueByKeyGuard.Unlock()
    // 从 map 查询值并返回的过程中，与不使用互斥量的写法一样
    // 对比上面的代码，这种写法更简单
    return valueByKey[key]
}
1
2
3
4
5
6
7
8
9
10
11

使用延迟释放文件句柄

文件的操作需要经过打开文件、获取和操作文件资源、关闭资源几个过程，如果在操作完毕后不关闭文件资源，进程将一直无法释放文件资源，在下面的例子中将实现根据文件名获取文件大小的函数，函数中需要打开文件、获取文件大小和关闭文件等操作，由于每一步系统操作都需要进行错误处理，而每一步处理都会造成一次可能的退出，因此就需要在退出时释放资源，而我们需要密切关注在函数退出处正确地释放文件资源，参考下面的代码：

// 根据文件名查询其大小
// 定义获取文件大小的函数，返回值是 64 位的文件大小值
func fileSize(filename string) int64 {
    // 根据文件名打开文件, 返回文件句柄和错误
    // 使用 os 包提供的函数 Open()，根据给定的文件名打开一个文件，并返回操作文件用的句柄和操作错误
    f, err := os.Open(filename)
    // 如果打开时发生错误, 返回文件大小为0
    // 如果打开的过程中发生错误，如文件没找到、文件被占用等，将返回文件大小为 0
    if err != nil {
        return 0
    }
    // 取文件状态信息
    // 此时文件句柄 f 可以正常使用，使用 f 的方法 Stat() 来获取文件的信息，获取信息时，可能也会发生错误
    info, err := f.Stat()
   
    // 如果获取信息时发生错误, 关闭文件并返回文件大小为0
    // 此时文件是正常打开的，为了释放资源，必须要调用 f 的 Close() 方法来关闭文件，否则会发生资源泄露
    if err != nil {
        f.Close()
        return 0
    }
    // 获取文件大小
    size := info.Size()
    // 关闭文件、释放资源
    f.Close()
   
    // 返回获取到的文件大小
    return size
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

func fileSize(filename string) int64 {
    f, err := os.Open(filename)
    if err != nil {
        return 0
    }
    // 延迟调用Close, 此时Close不会被调用
    defer f.Close()
    info, err := f.Stat()
    if err != nil {
        // defer机制触发, 调用Close关闭文件
        return 0
    }
    size := info.Size()
    // defer机制触发, 调用Close关闭文件
    return size
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在上面的例子中，对文件的关闭操作，下面使用 defer 对代码进行简化，代码如下：

func fileSize(filename string) int64 {
    f, err := os.Open(filename)
    if err != nil {
        return 0
    }
    // 延迟调用Close, 此时Close不会被调用
    // 在文件正常打开后，使用 defer，将 f.Close() 延迟调用
    // 注意，此语句不要放在打开文件Open函数和err函数之间
    // 否则一旦文件打开错误，f 将为空，在延迟语句触发时，将触发宕机错误
    defer f.Close()
    info, err := f.Stat()
    if err != nil {
    	// defer 后的语句（f.Close()）将会在函数返回前被调用，自动释放资源
        // defer机制触发, 调用Close关闭文件
        return 0
    }
    size := info.Size()
    // defer 后的语句（f.Close()）将会在函数返回前被调用，自动释放资源
    // defer机制触发, 调用Close关闭文件
    return size
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21