1. defer 的运作机制

defer 的运作离不开函数，这里至少有两点含义：

  • 在 Go 中，只有在函数(和方法)内部才能使用 defer；
  • defer 关键字后面只能接函数(或方法），这些函数被称为 deferred 函数。defer 将它们注册到其所在 goroutine 用于存放 deferred 函数的栈数据结构中，这些 deferred 函数将在执行 defer 的函数退出前被按后进先出(LIFO)的顺序调度执行(如下图所示)。

image.png

无论是执行到函数体尾部返回，还是在某个错误处理分支显式 return，亦或是出现 panic，已经存储到 deferred 函数栈中的函数都会被调度执行。因此，deferred 函数是一个可以在任何情况下都可以为函数进行收尾工作的好场合。

2. defer 的常见用法

1) 拦截 panic

可以如下面标准库代码中这样，重新 panic，但为新的 panic 传一个新的 error 值：

  1. // $GOROOT/src/bytes/buffer.go
  2. func makeSlice(n int) []byte {
  3.         // If the make fails, give a known error.
  4.         defer func() {
  5.                 if recover() != nil {
  6.                         panic(ErrTooLarge)
  7.                 }
  8.         }()
  9.         return make([]byte, n)
  10. }

下面代码则是通过 deferred 函数拦截 panic 并恢复了程序的继续运行：

  1. // deferred_func_3.go
  2. package main
  4. import "fmt"
  6. func bar() {
  7.     fmt.Println("raise a panic")
  8.     panic(-1)
  9. }
  11. func foo() {
  12.     defer func() {
  13.         if e := recover(); e != nil {
  14.             fmt.Println("recovered from a panic")
  15.         }
  16.     }()
  17.     bar()
  18. }
  20. func main() {
  21.     foo()
  22.     fmt.Println("main exit normally")
  23. }
  25. $ go run deferred_func_3.go
  26. raise a panic
  27. recovered from a panic
  28. main exit normally

当 bizOperation 抛出 panic 时，函数 g 无法释放 mutex，而函数 f 则可以释放 mutex，让后续函数依旧可以申请 mutex 资源。

  1. var mu sync.Mutex
  3. func f() {
  4.     mu.Lock()
  5.     defer mu.Unlock()
  6.     bizOperation()
  7. }
  9. func g() {
  10.     mu.Lock()
  11.     bizOperation()
  12.     mu.Unlock()
  13. }

虽然 deferred 函数可以拦截到绝大部分的 panic，但有些 runtime 之外的致命问题也是无法拦截并恢复的，比如下面代码中通过 C 代码”制造“的 crash，deferred 函数便无能为力：

  1. // deferred_func_4.go
  2. package main
  4. //#include <stdio.h>
  5. // void crash() {
  6. //    int *q = NULL;
  7. //    (*q) = 15000;
  8. //    printf("%d\n", *q);
  9. // }
  10. import "C"
  12. import (
  13.     "fmt"
  14. )
  16. func bar() {
  17.     C.crash()
  18. }
  20. func foo() {
  21.     defer func() {
  22.         if e := recover(); e != nil {
  23.             fmt.Println("recovered from a panic:", e)
  24.         }
  25.     }()
  26.     bar()
  27. }
  29. func main() {
  30.     foo()
  31.     fmt.Println("main exit normally")
  32. }

执行这段代码我们就会看到虽然有 deferred 函数拦截，但程序仍然崩溃掉了：

  1. $ go run deferred_func_4.go
  2. SIGILL: illegal instruction
  3. PC=0x409a7f4 m=0 sigcode=1
  5. goroutine 0 [idle]:
  6. runtime: unknown pc 0x409a7f4
  7. ... ...

2) deferred 函数可以修改函数的具名返回值

  1. // $GOROOT/src/fmt/scan.go
  2. func (s *ss) Token(skipSpace bool, f func(rune) bool) (tok []byte, err error) {
  3.         defer func() {
  4.                 if e := recover(); e != nil {
  5.                         if se, ok := e.(scanError); ok {
  6.                                 err = se.err
  7.                         } else {
  8.                                 panic(e)
  9.                         }
  10.                 }
  11.         }()
  12.     ... ...
  13. }
  15. // $GOROOT/SRC/net/ipsock_plan9.go 
  16. func dialPlan9(ctx context.Context, net string, laddr, raddr Addr) (fd *netFD, err error) {
  17.         defer func() { fixErr(err) }()
  18.     ... ...
  19. }

我们也来写一个更直观的示例：

  1. // deferred_func_5.go
  2. package main
  4. import "fmt"
  6. func foo(a, b int) (x, y int) {
  7.     defer func() {
  8.         x = x * 5
  9.         y = y * 10
  10.     }()
  12.     x = a + 5
  13.     y = b + 6
  14.     return
  15. }
  17. func main() {
  18.     x, y := foo(1, 2)
  19.     fmt.Println("x=", x, "y=", y)
  20. }

运行这个程序：

  1. $ go run deferred_func_5.go
  2. x= 30 y= 80

3) deferred 函数可以用于输出一些调试信息

  1. // $GOROOT/src/net/conf.go
  3. func (c *conf) hostLookupOrder(r *Resolver, hostname string) (ret hostLookupOrder) {
  4.         if c.dnsDebugLevel > 1 {
  5.                 defer func() {
  6.                         print("go package net: hostLookupOrder(", hostname, ") = ", ret.String(), "\n")
  7.                 }()
  8.         }
  9.     ... ...
  11. }

更为典型的莫过于在出入函数时打印留痕日志(一般在调试日志级别下)，这里摘录一下 Go 官方参考文档中提供的一个实现：

  1. func trace(s string) string {
  2.     fmt.Println("entering:", s)
  3.     return s
  4. }
  6. func un(s string) {
  7.     fmt.Println("leaving:", s)
  8. }
  10. func a() {
  11.     defer un(trace("a"))
  12.     fmt.Println("in a")
  13. }
  15. func b() {
  16.     defer un(trace("b"))
  17.     fmt.Println("in b")
  18.     a()
  19. }
  21. func main() {
  22.     b()
  23. }

4) 还原变量旧值

defer 还有一种比较小众的用法，这用法依旧是来自对 Go 标准库源码的阅读。在 syscall 包下面有这样的一段代码：

  1. // $GOROOT/src/syscall/fs_nacl.go
  2. func init() {
  3.         // do not trigger loading of zipped file system here
  4.         oldFsinit := fsinit
  5.         defer func() { fsinit = oldFsinit }()
  6.         fsinit = func() {}
  7.         Mkdir("/dev", 0555)
  8.         Mkdir("/tmp", 0777)
  9.         mkdev("/dev/null", 0666, openNull)
  10.         mkdev("/dev/random", 0444, openRandom)
  11.         mkdev("/dev/urandom", 0444, openRandom)
  12.         mkdev("/dev/zero", 0666, openZero)
  13.         chdirEnv()
  14. }

3. 关于 defer 使用的几个关键问题

1) 明确哪些函数可以作为 deferred 函数

对于自定义的函数或方法，defer 可以给与无条件的支持，但是对于有返回值的自定义函数或方法，返回值会在 deferred 函数被调度执行的时候被自动丢弃掉。

内置函数:

  1. Functions:
  2.     append cap close complex copy delete imag len
  3.     make new panic print println real recover

append、cap、len、make、new 等内置函数是不能直接作为 deferred 函数的，而 close、copy、delete、print、recover 等是可以直接被 defer 注册为 deferred 函数的。

对于那些不能直接作为 deferred 函数的内置函数，我们可以使用一个包裹它的匿名函数来间接满足要求，以 append 为例：

  1. defer func() {
  2.     _ = append(sl, 11)
  3. }()

2) 把握好 defer 关键字后面表达式的求值时机

牢记一点：defer 关键字后面的表达式是在将 deferred 函数注册到 deferred 函数栈的时候进行求值的。

下面用一个典型的例子来说明一下 defer 后表达式的求值时机：

  1. // deferred_func_7.go 
  2. package main
  4. import "fmt"
  6. func foo1() {
  7.     for i := 0; i <= 3; i++ {
  8.         defer fmt.Println(i)
  9.     }
  10. }
  12. func foo2() {
  13.     for i := 0; i <= 3; i++ {
  14.         defer func(n int) {
  15.             fmt.Println(n)
  16.         }(i)
  17.     }
  18. }
  20. func foo3() {
  21.     for i := 0; i <= 3; i++ {
  22.         defer func() {
  23.             fmt.Println(i)
  24.         }()
  25.     }
  26. }
  28. func main() {
  29.     fmt.Println("foo1 result:")
  30.     foo1()
  31.     fmt.Println("\nfoo2 result:")
  32.     foo2()
  33.     fmt.Println("\nfoo3 result:")
  34.     foo3()
  35. }
  • foo1 中 defer 后面直接用的是 fmt.Println 函数，每当 defer 将 fmt.Println 注册到 deferred 函数栈的时候，都会对 Println 后面的参数进行求值，根据上述代码逻辑，依次压入 deferred 函数栈的函数是：
  1. fmt.Println(0)
  2. fmt.Println(1)
  3. fmt.Println(2)
  4. fmt.Println(3)
  6. 3
  7. 2
  8. 1
  9. 0
  • foo2 中 defer 后面接的是一个带有一个参数的匿名函数。每当 defer 将匿名函数注册到 deferred 函数栈的时候，都会对该匿名函数的参数进行求值，根据上述代码逻辑，依次压入 deferred 函数栈的函数是：
  1. func(0)
  2. func(1)
  3. func(2)
  4. func(3)
  6. 3
  7. 2
  8. 1
  9. 0
  • foo3 中 defer 后面接的是一个不带参数的匿名函数。根据上述代码逻辑，依次压入 deferred 函数栈的函数是：
  1. func()
  2. func()
  3. func()
  4. func()

因此，当 foo3 返回后，deferred 函数被调度执行时，上述压入栈的 deferred 函数将以 LIFO 次序出栈执行。匿名函数以闭包的方式访问外围函数的变量 i，并通过 Println 输出 i 的值，此时 i 的值为 4，因此 foo3 的输出结果为：

  1. 4
  2. 4
  3. 4
  4. 4

鉴于 defer 表达式求值时机的重要性，我们再来看一个例子：

  1. // deferred_func_8.go 
  2. package main
  4. import "fmt"
  6. func foo1() {
  7.     sl := []int{1, 2, 3}
  8.     defer func(a []int) {
  9.         fmt.Println(a)
  10.     }(sl)
  12.     sl = []int{3, 2, 1}
  13.     _ = sl
  14. }
  15. func foo2() {
  16.     sl := []int{1, 2, 3}
  17.     defer func(p *[]int) {
  18.         fmt.Println(*p)
  19.     }(&sl)
  21.     sl = []int{3, 2, 1}
  22.     _ = sl
  23. }
  25. func main() {
  26.     foo1()
  27.     foo2()
  28. }
  • foo1 中 defer 后面的匿名函数接收一个切片类型参数，当 defer 将该匿名函数注册到 deferred 函数栈的时候，会对它的参数进行求值，此时传入的变量 sl 的值为[]int{1, 2, 3}，因此压入 deferred 函数栈的函数是：
  1. func([]int{1,2,3})

之后虽然 sl 被重新赋值，但是当 foo1 返回后，deferred 函数被调度执行时，deferred 函数的参数值依然为[]int{1,2,3}，因此 foo1 输出的结果为：[1 2 3]。

  • foo2 中 defer 后面的匿名函数接收一个切片指针类型参数，当 defer 将该匿名函数注册到 deferred 函数栈的时候，会对它的参数进行求值，此时传入的参数为变量 sl 的地址，因此压入 deferred 函数栈的函数是：
  1. func(&sl)

之后虽然 sl 被重新赋值。当 foo2 返回后，deferred 函数被调度执行时，deferred 函数的参数值依然为 sl 的地址，但此时 sl 的值已经变为[]int{3, 2, 1}，因此 foo2 输出的结果为：[3 2 1]。

3) 知晓 defer 带来的性能损耗

我们用一个性能基准测试(benchmark)来直观地看看 defer 究竟带来多少性能损耗。

  1. // defer_perf_benchmark_1_test.go 
  2. package defer_test
  4. import "testing"
  6. func sum(max int) int {
  7.     total := 0
  8.     for i := 0; i < max; i++ {
  9.         total += i
  10.     }
  12.     return total
  13. }
  15. func fooWithDefer() {
  16.     defer func() {
  17.         sum(10)
  18.     }()
  19. }
  20. func fooWithoutDefer() {
  21.     sum(10)
  22. }
  24. func BenchmarkFooWithDefer(b *testing.B) {
  25.     for i := 0; i < b.N; i++ {
  26.         fooWithDefer()
  27.     }
  28. }
  29. func BenchmarkFooWithoutDefer(b *testing.B) {
  30.     for i := 0; i < b.N; i++ {
  31.         fooWithoutDefer()
  32.     }
  33. }

运行该 benchmark 测试，我们得到如下结果：

  1. $ go test -bench . defer_perf_benchmark_1_test.go 
  2. goos: darwin
  3. goarch: amd64
  4. BenchmarkFooWithDefer-8          34581608            31.6 ns/op
  5. BenchmarkFooWithoutDefer-8       248793603             4.83 ns/op
  6. PASS
  7. ok      command-line-arguments    2.830s

我的测试:

  1. $ go version
  2. go version go1.15.8 linux/amd64
  4. $ go test -bench . cli_test.go 
  5. goos: linux
  6. goarch: amd64
  7. BenchmarkFooWithDefer-8         153751154                7.65 ns/op
  8. BenchmarkFooWithoutDefer-8      238873606                5.02 ns/op
  9. PASS
  10. ok      command-line-arguments  3.677s