golang中defer,panic,recover是很常用的三个特性，三者一起使用可以充当其他语言中try…catch…的角色，而defer本身又像其他语言的析构函数
defer
defer后边会接一个函数，但该函数不会立刻被执行，而是等到包含它的程序返回时(包含它的函数执行了return语句、运行到函数结尾自动返回、对应的goroutine panic）defer函数才会被执行。通常用于资源释放、打印日志、异常捕获等
func main() {
f, err := os.Open(filename)
if err != nil {
return err
}
/**
* 这里defer要写在err判断的后边而不是os.Open后边
* 如果资源没有获取成功，就没有必要对资源执行释放操作
* 如果err不为nil而执行资源执行释放操作，有可能导致panic
*/
defer f.Close()
}
如果有多个defer函数，调用顺序类似于栈，越后面的defer函数越先被执行(后进先出)
func main() {
defer fmt.Println(1)
defer fmt.Println(2)
defer fmt.Println(3)
defer fmt.Println(4)
}
结果：
4
3
2
1
如果包含defer函数的外层函数有返回值，而defer函数中可能会修改该返回值，最终导致外层函数实际的返回值可能与你想象的不一致，这里很容易踩坑，来几个🌰
例1
func f() (result int) {
defer func() {
result++
}()
return 0
}
例2
func f() (r int) {
t := 5
defer func() {
t = t + 5
}()
return t
}
例3
func f() (r int) {
defer func(r int) {
r = r + 5
}(r)
return 1
}
请先不要向下看，在心里跑一遍上边三个例子的结果，然后去验证
可能你会认为：例1的结果是0，例2的结果是10，例3的结果是6，那么很遗憾的告诉你，这三个结果都错了
为什么呢，最重要的一点就是要明白，return xxx这一条语句并不是一条原子指令
含有defer函数的外层函数，返回的过程是这样的：先给返回值赋值，然后调用defer函数，最后才是返回到更上一级调用函数中，可以用一个简单的转换规则将return xxx改写成
返回值 = xxx
调用defer函数(这里可能会有修改返回值的操作)
return 返回值
例1可以改写成这样
func f() (result int) {
result = 0
//在return之前，执行defer函数
func() {
result++
}()
return
}
所以例1的返回值是1
例2可以改写成这样
func f() (r int) {
t := 5
//赋值
r = t
//在return之前，执行defer函数，defer函数没有对返回值r进行修改，只是修改了变量t
func() {
t = t + 5
}
return
}
所以例2的结果是5
例3可以改写成这样
func f() (r int) {
//给返回值赋值
r = 1
/**
* 这里修改的r是函数形参的值，是外部传进来的
* func(r int){}里边r的作用域只该func内，修改该值不会改变func外的r值
*/
func(r int) {
r = r + 5
}(r)
return
}
所以例3的结果是1
defer函数的参数值，是在申明defer时确定下来的
在defer函数申明时，对外部变量的引用是有两种方式：作为函数参数和作为闭包引用
作为函数参数，在defer申明时就把值传递给defer，并将值缓存起来，调用defer的时候使用缓存的值进行计算（如上边的例3）
而作为闭包引用，在defer函数执行时根据整个上下文确定当前的值
看个🌰
func main() {
i := 0
defer fmt.Println("a:", i)
//闭包调用，将外部i传到闭包中进行计算，不会改变i的值，如上边的例3
defer func(i int) {
fmt.Println("b:", i)
}(i)
//闭包调用，捕获同作用域下的i进行计算
defer func() {
fmt.Println("c:", i)
}()
i++
}
结果：
c: 1
b: 0
a: 0
panic和recover
func panic(v interface{})
中英文说明
The panic built-in function stops normal execution of the current goroutine.When a function F calls panic, normal execution of F stops immediately.Any functions whose execution was deferred by F are run in the usual way, and then F returns to its caller. To the caller G, the invocation of F then behaves like a call to panic,terminating G's execution and running any deferred functions.This continues until all functions in the executing goroutine have stopped,in reverse order. At that point, the program is terminated and the error condition is reported,including the value of the argument to panic. This termination sequence is called panicking and can be controlled by the built-in function recover.
panic内置函数停止当前goroutine的正常执行，当函数F调用panic时，函数F的正常执行被立即停止，然后运行所有在F函数中的defer函数，然后F返回到调用他的函数对于调用者G，F函数的行为就像panic一样，终止G的执行并运行G中所defer函数，此过程会一直继续执行到goroutine所有的函数。panic可以通过内置的recover来捕获。
func recover() interface{}
中英文说明
The recover built-in function allows a program to manage behavior of a panicking goroutine. Executing a call to recover inside a deferred function (but not any function called by it) stops the panicking sequence by restoring normal execution and retrieves the error value passed to the call of panic. If recover is called outside the deferred function it will not stop a panicking sequence. In this case, or when the goroutine is not panicking, or if the argument supplied to panic was nil, recover returns nil. Thus the return value from recover reports whether the goroutine is panicking.
recover内置函数用来管理含有panic行为的goroutine，recover运行在defer函数中，获取panic抛出的错误值，并将程序恢复成正常执行的状态。如果在defer函数之外调用recover，那么recover不会停止并且捕获panic错误如果goroutine中没有panic或者捕获的panic的值为nil，recover的返回值也是nil。由此可见，recover的返回值表示当前goroutine是否有panic行为
这里有几个需要注意的问题，通过🌰表现
1、defer 表达式的函数如果定义在 panic 后面，该函数在 panic 后就无法被执行到
在defer前panic
func main() {
panic("a")
defer func() {
fmt.Println("b")
}()
}
结果，b没有被打印出来：
panic: a
goroutine 1 [running]:
main.main()
/xxxxx/src/xxx.go:50 +0x39
exit status 2
而在defer后panic
func main() {
defer func() {
fmt.Println("b")
}()
panic("a")
}
结果，b被正常打印：
b
panic: a
goroutine 1 [running]:
main.main()
/xxxxx/src/xxx.go:50 +0x39
exit status 2
2、F中出现panic时，F函数会立刻终止，不会执行F函数内panic后面的内容，但不会立刻return，而是调用F的defer，如果F的defer中有recover捕获，则F在执行完defer后正常返回，调用函数F的函数G继续正常执行
func G() {
defer func() {
fmt.Println("c")
}()
F()
fmt.Println("继续执行")
}
func F() {
defer func() {
if err := recover(); err != nil {
fmt.Println("捕获异常:", err)
}
fmt.Println("b")
}()
panic("a")
}
结果：
捕获异常: a
b
继续执行
c
3、如果F的defer中无recover捕获，则将panic抛到G中，G函数会立刻终止，不会执行G函数内后面的内容，但不会立刻return，而调用G的defer...以此类推
func G() {
defer func() {
if err := recover(); err != nil {
fmt.Println("捕获异常:", err)
}
fmt.Println("c")
}()
F()
fmt.Println("继续执行")
}
func F() {
defer func() {
fmt.Println("b")
}()
panic("a")
}
结果：
b
捕获异常: a
c
4、如果一直没有recover，抛出的panic到当前goroutine最上层函数时，程序直接异常终止
func G() {
defer func() {
fmt.Println("c")
}()
F()
fmt.Println("继续执行")
}
func F() {
defer func() {
fmt.Println("b")
}()
panic("a")
}
结果：
b
c
panic: a
goroutine 1 [running]:
main.F()
/xxxxx/src/xxx.go:61 +0x55
main.G()
/xxxxx/src/xxx.go:53 +0x42
exit status 2
5、recover都是在当前的goroutine里进行捕获的，这就是说，对于创建goroutine的外层函数，如果goroutine内部发生panic并且内部没有用recover，外层函数是无法用recover来捕获的，这样会造成程序崩溃
func G() {
defer func() {
//goroutine外进行recover
if err := recover(); err != nil {
fmt.Println("捕获异常:", err)
}
fmt.Println("c")
}()
//创建goroutine调用F函数
go F()
time.Sleep(time.Second)
}
func F() {
defer func() {
fmt.Println("b")
}()
//goroutine内部抛出panic
panic("a")
}
结果：
b
panic: a
goroutine 5 [running]:
main.F()
/xxxxx/src/xxx.go:67 +0x55
created by main.main
/xxxxx/src/xxx.go:58 +0x51
exit status 2
6、recover返回的是interface{}类型而不是go中的 error 类型，如果外层函数需要调用err.Error()，会编译错误，也可能会在执行时panic
func main() {
defer func() {
if err := recover(); err != nil {
fmt.Println("捕获异常:", err.Error())
}
}()
panic("a")
}
编译错误，结果：
err.Error undefined (type interface {} is interface with no methods)
func main() {
defer func() {
if err := recover(); err != nil {
fmt.Println("捕获异常:", fmt.Errorf("%v", err).Error())
}
}()
panic("a")
}
结果：
捕获异常: a
参考：
https: //golang.org/pkg/builtin/#recover
https: //www.w3cschool.cn/go_internals/go_internals-drq7282o.html
