使用 Go defer 要小心这 2 个雷区！-优快云博客

本文链接：https://blog.youkuaiyun.com/wuchaoyong0413/article/details/146232841

文章正文

在 Go 语言中，defer 是一个非常强大的关键字，用于延迟执行函数调用，通常用于资源释放、错误处理等场景。然而，随着 Go 语言的版本迭代，defer 的实现和性能也在不断优化。

本文将深入探讨 Go 1.20 中 defer 的优化机制，并揭示在使用 defer 时需要避免的两个常见陷阱。

1. Go 1.20 中的 defer 优化

在 Go 1.13 中，defer 的性能得到了显著提升，主要得益于编译器对 defer 的堆栈分配优化。而在 Go 1.20 中，defer 的优化进一步得到了增强，特别是在处理循环中的 defer 时，编译器能够更智能地决定 defer 对象的分配方式。

1.1 堆栈分配优化

在 Go 1.20 中，编译器会根据 defer 的使用场景，自动选择将其分配在栈上还是堆上。对于大多数简单的 defer 调用，编译器会优先将其分配在栈上，从而避免了堆分配带来的性能开销。

package main

import "fmt"

func main() {
    defer fmt.Println("Go 1.20 defer 优化")
    fmt.Println("开始执行")
}

输出结果：

开始执行
Go 1.20 defer 优化

在这个例子中，defer 语句被分配在栈上，执行效率更高。

1.2 循环中的 defer 优化

在 Go 1.20 中，编译器对循环中的 defer 进行了更智能的处理。如果编译器能够确定循环的迭代次数较少，它会将 defer 分配在栈上，从而避免频繁的堆分配。

package main

import "fmt"

func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Println("迭代次数:", i)
    }
    fmt.Println("循环结束")
}

输出结果：

循环结束
迭代次数: 2
迭代次数: 1
迭代次数: 0

在这个例子中，由于循环次数较少，编译器将 defer 分配在栈上，避免了堆分配的开销。

2. 使用 defer 时需要避免的两个陷阱

尽管 Go 1.20 对 defer 进行了优化，但在某些情况下，不当使用 defer 仍然会导致性能问题。以下是两个常见的陷阱：

2.1 显式循环中的 defer

在显式循环中使用 defer 可能会导致 defer 链表过长，从而影响性能。特别是在循环次数较多的情况下，defer 链表会变得非常庞大，导致内存占用增加和性能下降。

package main

import "fmt"

func main() {
    for i := 0; i < 10000; i++ {
        defer fmt.Println("显式循环中的 defer:", i)
    }
    fmt.Println("显式循环结束")
}

在这个例子中，defer 链表会包含 10000 个节点，导致内存占用增加和性能下降。

2.2 隐式循环中的 defer

隐式循环中的 defer 同样会导致性能问题。例如，使用 goto 语句实现的隐式循环会导致 defer 链表不断增长，从而影响性能。

package main

import "fmt"

func main() {
    i := 1
food:
    defer func() {
        fmt.Println("隐式循环中的 defer")
    }()
    if i == 1 {
        i -= 1
        goto food
    }
    fmt.Println("隐式循环结束")
}