理解 Go defer, panic, recover

不像 Go 的其他流程控制(if, for, switch, goto, go) 一样, defer, panic 和 recover 用的比较少.

Defer

defer 语句会将函数调用放入一个列表. 当外围的函数执行返回后列表内保存的函数调用会被执行. defer 像 Python 的 with, finally 一样都具有类似资源情理的作用. 当然 defer 在这方面更灵活.

defer 的行为遵循 3 个简单的原则:

一个 defer 函数的参数在放入待调用列表的时候被立即求值. 比如:
```
func a() {
    i := 0
    defer fmt.Println(i) // @1
    i++
    return
}
```
这个例子中, @1 中的 i 会被立即求值, 所以 a 函数调用返回时, 会打印出 “0” 而不是 “1”.

defer 函数在外围函数返回时遵循 先进后出 的调用顺序.

func b() {
    for i := 0; i < 4; i++ {
        defer fmt.Print(i)
    }
}

b 函数将会打印出 “3210”.

defer 函数会读取并且赋值外围函数的命名返回值(named return values).
```
func c() (i int) {
    defer func() { i++ }()
    return 1
}
```
这个例子中 i 的值会在 defer 被调用时执行加 1 操作, 所以 c 将返回 2. 这对于修改一个函数的 error 返回值很方便.

Panic

panic 是一个内置的函数用来阻断一般的控制流程. Go spec 对于 panic 有一段描述:

当执行函数 F 时, 一个明确的 panic 调用或者运行时 panic(数组越界访问等)会终止 F 的执行. F 所属的任何 defer 函数继续执行. 紧接着, 任何 F 调用者的 defer 函数运行, 而且对于执行中的 goroutine 中的任何顶层 defer 函数也是如此. 到那时, 程序终止并且报错(错误包含在 panic 参数中). 该终止序列被称为 panicking.

Recover

recover 是一个内建函数用来恢复一个 panicking 的 goroutine. Go spec 对于 recover 有一段描述:

设想有一个函数 G, 有一个 defer 函数会调用 recover 并且和 G 在同一 goroutine 的函数发生了 panic. 当运行到 defer 函数 D 调用的时候, D 调用 recover 的返回值是 panic 调用时传入的值. 如果 D 正常返回, 没有开启一个新的 panic, panicking 序列会终止. 在这种情况下, G 和 panic 之间的函数调用状态被废弃, 并且正常的调用恢复. 然后 G 中任何在 D 之前的 defer 函数会执行, 并且 G 的执行通过返回到它的调用者而终止.

以下情况中 recover 的返回值为 nil:

panic 参数为 nil;
当前 goroutine 没有发生 panicking;
recover 没有被一个 defer 函数直接调用.

以下示例程序演示了 panic 和 defer 的原理:

package main

import "fmt"

func main() {
    f()
    fmt.Println("Returned normally from f.")
}

func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
    fmt.Println("Calling g.")
    g(0)
    fmt.Println("Returned normally from g.")
}

func g(i int) {
    if i > 3 {
        fmt.Println("Panicking!")
        panic(fmt.Sprintf("%v", i))
    }
    defer fmt.Println("Defer in g", i)
    fmt.Println("Printing in g", i)
    g(i + 1)
}

函数返回:

Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
Recovered in f 4
Returned normally from f.

如果我们移除 f 中 defer 将输出:

Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
panic: 4

panic PC=0x2a9cd8
[stack trace omitted]

Go 标准库中的约定是, 即使一个包在内部使用 panic, 其外部 API 仍会给出明确的错误返回值(真实的例子可以参见标准库 json 包). 这是很好的使用原则, 尤其当我们写自己库的时候, 难免需要处理来自第三方的包返回的各种 error, 如果不需要处理, 简单的一个 panic 会是很好的方案.

结束

到这里可能就是你所能看到的关于 defer, panic 和 recover 的所有"坑"(我一向不觉得文档中有的你没看到的东西叫坑). 下面的内容可以不看了, 但是你看了, 保证没坏处.

当然可能有人说 recover 不能恢复所有的 panic, 比如如下的程序:

package main

import (
	"fmt"
	"sync"
)

func main() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("recovered")
		}
	}()

	m := map[int]int{}
	var wg sync.WaitGroup

	for i := 0; i < 10; i++ {
		wg.Add(1)
		v := i
		go func() {
			defer wg.Done()
			m[v] = v
		}()
	}
	wg.Wait()
}

如果运行该程序, 那么会得到如下的输出:

fatal error: concurrent map writes
fatal error: concurrent map writes
...

其实这个不叫 panic, 按官方文档的说法叫: 崩溃(crash) 和内存腐败(memory corruption). 由于程序无视 Go 内存模型而导致的数据竞争(data race).

当然对于以上程序来说, 运行程序崩溃是显而易见的, 然而有的程序运行时不会显式的的崩溃, 如:

package main

import "fmt"

func main() {
	c := make(chan bool)
	m := make(map[string]string)
	go func() {
		m["1"] = "a"
		c <- true
	}()
	m["2"] = "b"
	<-c
	for k, v := range m {
		fmt.Println(k, v)
	}
}

输出:

2 b
1 a

为了检测和预防这种崩溃, Go 内建了数据竞争探测器(data race detector), 可以通过传递 flag: -race 给 go 命令来启用:

$ go test -race mypkg
$ go run -race mysrc.go
$ go build -race mycmd
$ go install -race mypkg

我们再次对上面的程序使用命令: go run -race main.go, 那么数据探测器可以检测到:

==================
WARNING: DATA RACE
Write at 0x00c420090180 by goroutine 6:
  runtime.mapassign_faststr()
      /usr/local/Cellar/go/1.10/libexec/src/runtime/hashmap_fast.go:694 +0x0
  main.main.func1()
      /Users/a/.go/src/github.com/gorocks/snippets/go/cmd/gosnippets/main.go:9 +0x5d

Previous write at 0x00c420090180 by main goroutine:
  runtime.mapassign_faststr()
      /usr/local/Cellar/go/1.10/libexec/src/runtime/hashmap_fast.go:694 +0x0
  main.main()
      /Users/a/.go/src/github.com/gorocks/snippets/go/cmd/gosnippets/main.go:12 +0xc9

Goroutine 6 (running) created at:
  main.main()
      /Users/a/.go/src/github.com/gorocks/snippets/go/cmd/gosnippets/main.go:8 +0x9a
==================
1 a
2 b
Found 1 data race(s)
exit status 66

Defer

Panic

Recover

结束

参考资料