golang中defer,panic,recover是很常用的三个特性，三者一起使用可以充当其他语言中try…catch…的角色，而defer本身又像其他语言的析构函数
defer
在函数返回之前调用，用于资源释放、打印日志、异常捕获等
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) {
//return语句不是一条原子调用，return xxx其实是赋值＋ret指令
result = 0
//defer被插入到return之前执行，也就是赋返回值和ret指令之间
func() {
result++
}()
return
}
所以这个返回值是1
例2，它可以改写成这样
func f() (r int) {
t := 5
//赋值指令
r = t
//defer被插入到赋值与返回之间执行，这个例子中返回值r没被修改过
func() {
t = t + 5
}
return
}
所以这个的结果是5
例3，它可以改写成这样
func f() (r int) {
//给返回值赋值
r = 1
//这里改的r是传值传进去的r(func里边的r是作用域不同的重名变量)，不会改变要返回的那个r值
func(r int) {
r = r + 5
}(r)
return
}
所以这个例子的结果是1
defer被插入到了赋值与ret之间，因此可能有机会改变最终的返回值
defer函数的参数值，是在申明defer时确定下来的
在defer函数申明时，对外部变量的引用是有两种方式：作为函数参数和作为闭包引用
作为函数参数，在defer申明时就把值传递给defer，并将值缓存起来，调用defer的时候使用缓存的值进行计算
作为闭包引用，在defer函数执行时根据整个上下文确定当前的值
看个????
func main() {
i := 0
defer fmt.Println("a:", i)
//闭包调用，将外部i传到闭包中进行计算
defer func(j int) {
fmt.Println("b:", j)
}(i)
//闭包调用，捕获同作用域下的i进行计算
defer func() {
fmt.Println("c:", i)
}()
i++
}
结果：
c: 1
b: 0
a: 0
说明地址：https://www.jianshu.com/p/63e3d57f285f
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行为
这里有几个需要注意的问题，通过????表现
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
F中出现panic时，F函数会立刻终止，不会执行F函数中后面的内容，但不会立刻返回，而调用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
如果F的defer中无recover捕获，则将panic抛到G中，G函数会立刻终止，不会执行G函数中后面的内容，但不会立刻返回，而调用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
如果一直没有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
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
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
