Go defer 延迟执行

编写程序时,像关闭文件、断开连接这类收尾工作,很容易因为代码较长或中途提前退出而忘记执行。Go 语言专门提供了一个非常实用的关键字 defer,它的英文原意就是 “推迟、延后”。

只要我们在一条函数调用语句前面加上 defer,这条语句就不会在当前位置立即运行,而是会自动推迟到当前函数即将返回之前才执行。

defer 基本用法

在 Go 语言中,使用 defer 的语法非常简单,我们只需要在普通的函数调用前面加上 defer 关键字即可。

语法:

defer 函数名(参数列表)

说明:

当程序执行到带有 defer 的语句时,系统会先把这次函数调用记录下来,然后继续往下执行后面的普通代码。等到当前函数执行到末尾,或者中途遇到 return 语句即将退出之前,系统才会自动执行刚才推迟的 defer 语句。

示例 1:使用 defer 推迟执行

package main

import "fmt"

func main() {
    fmt.Println("程序开始")
    defer fmt.Println("[defer] 延迟执行")
    fmt.Println("程序结束")
}

运行结果如下。

程序开始
程序结束
[defer] 延迟执行

分析:

在上面代码中,虽然 defer fmt.Println("[defer] 延迟执行") 写在第 2 行,但它并没有紧跟着第 1 句打印出来。

程序会先按顺序执行完 "程序开始" 和 "程序结束" 这两句普通代码。等到整个 main() 函数即将退出时,系统才回头执行被推迟的打印语句。

注意:

  • 后面必须跟函数调用:defer 关键字后面必须跟一个完整的函数调用,也就是末尾必须带有小括号 ()。比如写成 defer x = 10 就是错误的,编译时会直接报错。
  • 归属于整个函数而非局部代码块:哪怕把 defer 写在 if 或 for 的花括号 {} 内部,它也不会在离开这层花括号时执行,而是依然要等到当前整个函数即将结束时才执行。

多个 defer 的执行顺序

如果在同一个函数内部连续写了多条 defer 语句,函数结束时它们会按照什么顺序执行呢?

在 Go 语言中,多个 defer 语句遵循 “后进先出(LIFO)” 的倒序规则,也就是越晚写下的 defer 语句越早执行。

这个过程和日常生活中的 “叠盘子” 是一个道理:第 1 个盘子放在最底下,第 2 个叠在中间,第 3 个放在最顶上。等我们需要把盘子拿出来使用时,自然是从最顶上的第 3 个开始往下拿,顺序依次是 3、2、1。

示例 2:多个 defer 的执行顺序

package main

import "fmt"

func main() {
    fmt.Println("开始执行")
    defer fmt.Println(1)
    defer fmt.Println(2)
    defer fmt.Println(3)
    fmt.Println("普通代码执行完毕")
}

运行结果如下。

开始执行
普通代码执行完毕
3
2
1

分析:

在这个例子中,我们在 main() 函数内依次写下了打印 1、2、3 的 3 条 defer 语句。当普通代码全部执行完毕后,这 3 条语句会按照从下往上的倒序依次执行,因此最终输出了 3、2、1。

多个 defer 语句的记录与执行顺序如下图所示。

多个 defer 后进先出的执行顺序

defer 参数的求值时机

使用 defer 时有一个小伙伴们很容易忽略的细节:虽然 defer 后面的函数会推迟到最后才执行,但传给该函数的参数,在程序走到 defer 那一行时就已经立即算出并固定下来了。

示例 3:defer 参数立即求值

package main

import "fmt"

func main() {
    x := 10
    defer fmt.Println("defer 中的 x =", x)
    x = 20
    fmt.Println("修改后的 x =", x)
}

运行结果如下。

修改后的 x = 20
defer 中的 x = 10

分析:

defer 明明是在函数最后才执行的,那时 x 已经改成了 20,为什么打印出来的还是 10 呢?

这是因为当程序运行到 defer fmt.Println("defer 中的 x =", x) 这一行时,系统就已经把当时 x 的值 10 读取出来并保存好了,只是把打印动作推迟到了函数末尾。因此后面我们再把 x 修改为 20,并不会改变前面已经固定下来的参数值。

如果我们确实希望在函数结束时读取到 x 修改后的最新值,应该怎么写呢?这时可以配合前面学过的匿名函数,把打印语句包在一个无参匿名函数里延迟执行。

示例 4:配合匿名函数读取最新值

package main

import "fmt"

func main() {
    x := 10
    defer func() {
        fmt.Println("defer 中的 x =", x)
    }()
    x = 20
    fmt.Println("修改后的 x =", x)
}

运行结果如下。

修改后的 x = 20
defer 中的 x = 20

分析:

这里小伙伴们还要留意一点:因为 defer 后面必须跟一个函数调用,所以匿名函数右花括号末尾必须加上一对小括号 ()。

这个无参匿名函数没有通过参数传值,而是直接引用了外部变量 x,与 x 构成了闭包。因为闭包捕获的是变量 x 本身而不是创建时的数值快照,等到 main() 函数即将结束、真正执行匿名函数内部的代码时再去读取 x,拿到的就是修改后的最新值 20 了。

defer 的应用场景

在实际开发中,defer 最常见的用途就是 “成对管理资源的打开与关闭”。比如我们在读取文件或连接数据库时,打开资源之后必须记得把它关闭。

如果不使用 defer,当函数代码较长或者中途有多处 return 提前返回时,我们很容易漏写关闭代码。有了 defer 之后,只要在打开资源的下一行紧挨着写好关闭操作,无论函数从哪个分支退出都能自动清理资源。

示例 5:自动释放打开的资源

package main

import "fmt"

func readData(isValid bool) {
    fmt.Println("[打开] 打开文件资源")
    defer fmt.Println("[关闭] 关闭文件资源")    // 紧挨打开操作写好关闭语句

    if !isValid {
        fmt.Println("[中止] 校验未通过,提前返回")
        return
    }
    fmt.Println("[处理] 正常读取并处理数据")
}

func main() {
    readData(false)
    fmt.Println("---")
    readData(true)
}

运行结果如下。

[打开] 打开文件资源
[中止] 校验未通过,提前返回
[关闭] 关闭文件资源
---
[打开] 打开文件资源
[处理] 正常读取并处理数据
[关闭] 关闭文件资源

分析:

在 readData() 函数中,我们在打开资源后紧接着就在下一行写上了 defer 关闭操作。把 “打开” 和 “关闭” 两行代码紧挨着放在一起,逻辑直观,不容易遗漏关闭步骤。

从两次调用的结果可以看出:当我们第 1 次传入 false 时,函数在 if 分支遇到 return 提前退出。当我们第 2 次传入 true 时,函数正常执行到最后一行结束。无论走哪一条路径,defer 关闭语句都会在函数退出前自动执行,确保资源正常释放。

结合第 1 节提到的规则,实际开发时还有一个高频大坑,小伙伴们一定要提前避开:千万不要直接在 for 循环内部使用 defer 来关闭文件或网络连接。

因为 defer 要等到当前整个函数结束时才统一执行。如果循环里依次打开了 1000 个文件,这些资源就会一直占着不释放,全部积压到函数退出那一刻,很容易把系统资源耗尽。

想要解决这个问题其实非常简单:我们可以把单次循环里的 “打开、处理、defer 关闭” 封装成一个独立的小函数,也可以用立即执行匿名函数包一层。这样每跑完一轮循环,小函数一结束就能立刻释放当次资源。

// 不推荐
for _, name := range files {
    openFile(name)
    defer closeFile(name)
}

// 推荐
for _, name := range files {
    processFile(name)    // 在函数内部 defer 关闭
}

养成 “打开资源就紧跟 defer,循环处理就抽成小函数” 的习惯,后面编写文件操作和网络代码时会省心很多。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号