关于golang:听说99-的-Go-程序员都被-defer-坑过

原文链接： 据说，99% 的 Go 程序员都被 defer 坑过

先申明：我被坑过。

之前写 Go 专栏时，写过一篇文章：Go 专栏｜错误处理：defer，panic 和 recover。有小伙伴留言说：情理都懂，但还是不晓得怎么用，而且还总呈现莫名微妙的问题。

出问题就对了，这个小东西坏的很，一不留神就出错。

所以，面对这种状况，咱们明天就不讲道理了。间接把我收藏多年的代码一把梭，凭借多年踩坑经验和写 BUG 教训，我要站着把这个坑迈过去。

一、

先来一个简略的例子热热身：

package mainimport (    "fmt")func main() {    defer func() {        fmt.Println("first")    }()    defer func() {        fmt.Println("second")    }()    fmt.Println("done")}

输入：

donesecondfirst

这个比较简单，defer 语句的执行程序是按调用 defer 语句的倒序执行。

二、

看看这段代码有什么问题？

for _, filename := range filenames {    f, err := os.Open(filename)    if err != nil {        return err    }    defer f.Close()}

这段代码其实很危险，很可能会用尽所有文件描述符。因为 defer 语句不到函数的最初一刻是不会执行的，也就是说文件始终得不到敞开。所以切记，肯定不要在 for 循环中应用 defer 语句。

那怎么优化呢？能够将循环体独自写一个函数，这样每次循环的时候都会调用敞开函数。

如下：

for _, filename := range filenames {    if err := doFile(filename); err != nil {        return err    }}func doFile(filename string) error {    f, err := os.Open(filename)    if err != nil {        return err    }    defer f.Close()}

三、

看看这三个函数的输入后果是什么？

package mainimport (    "fmt")func a() (r int) {    defer func() {        r++    }()    return 0}func b() (r int) {    t := 5    defer func() {        t = t + 5    }()    return t}func c() (r int) {    defer func(r int) {        r = r + 5    }(r)    return 1}func main() {    fmt.Println("a = ", a())    fmt.Println("b = ", b())    fmt.Println("c = ", c())}

颁布答案：

a =  1b =  5c =  1

你答对了吗？

说实话刚开始看到这个后果时，我是相当费解，齐全不晓得怎么回事。

但能够看到，这三个函数都有一个独特特点，它们都有一个命名返回值，并且都在函数中援用了这个返回值。

援用的形式分两种：别离是闭包和函数参数。

先看 a() 函数：

闭包通过 r++ 批改了内部变量，返回值变成了 1。

相当于：

func aa() (r int) {    r = 0    // 在 return 之前，执行 defer 函数    func() {        r++    }()    return}

再看 b() 函数：

闭包内批改的只是局部变量 t，而内部变量 t 不受影响，所以还是返回 5。

相当于：

func bb() (r int) {    t := 5    // 赋值    r = t    // 在 return 之前，执行 defer 函数    // defer 函数没有对返回值 r 进行批改，只是批改了变量 t    func() {        t = t + 5    }()    return}

最初是 c 函数：

参数传递是值拷贝，实参不受影响，所以还是返回 1。

相当于：

func cc() (r int) {    // 赋值    r = 1    // 这里批改的 r 是函数形参的值    // 值拷贝，不影响实参值    func(r int) {        r = r + 5    }(r)    return}

那么，为了防止写出这么令人意外的代码，最好在定义函数时就不要应用命名返回值。或者如果应用了，就不要在 defer 中援用。

再看上面两个例子：

func d() int {    r := 0    defer func() {        r++    }()    return r}func e() int {    r := 0    defer func(i int) {        i++    }(r)    return 0}

d =  0e =  0

返回值合乎预期，再也不必搜索枯肠猜了。

四、

defer 表达式的函数如果在 panic 前面，则这个函数无奈被执行。

func main() {    panic("a")    defer func() {        fmt.Println("b")    }()}

输入如下，b 没有打印进去。

panic: agoroutine 1 [running]:main.main()    xxx.go:87 +0x4ceexit status 2

而如果 defer 在前，则能够执行。

func main() {    defer func() {        fmt.Println("b")    }()    panic("a")}

输入：

bpanic: agoroutine 1 [running]:main.main()    xxx.go:90 +0x4e7exit status 2

五、

看看上面这段代码的执行程序：

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")}func main() {    G()}

程序如下：

调用 G() 函数；
调用 F() 函数；
F() 中遇到 panic，立即终止，不执行 panic 之后的代码；
执行 F() 中 defer 函数，遇到 recover 捕捉谬误，继续执行 defer 中代码，而后返回；
执行 G() 函数后续代码，最初执行 G() 中 defer 函数。

输入：

捕捉异样: ab继续执行c

五、

看看上面这段代码的执行程序：

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")}func main() {    G()}

程序如下：

调用 G() 函数；
调用 F() 函数；
F() 中遇到 panic，立即终止，不执行 panic 之后的代码；
执行 F() 中 defer 函数，因为没有 recover，则将 panic 抛到 G() 中；
G() 收到 panic 则不会执行后续代码，间接执行 defer 函数；
defer 中捕捉 F() 抛出的异样 a，而后继续执行，最初退出。

输入：

b捕捉异样: ac

六、

看看上面这段代码的执行程序：

func G() {    defer func() {        fmt.Println("c")    }()    F()    fmt.Println("继续执行")}func F() {    defer func() {        fmt.Println("b")    }()    panic("a")}func main() {    G()}

程序如下：

调用 G() 函数；
调用 F() 函数；
F() 中遇到 panic，立即终止，不执行 panic 之后的代码；
执行 F() 中 defer 函数，因为没有 recover，则将 panic 抛到 G() 中；
G() 收到 panic 则不会执行后续代码，间接执行 defer 函数；
因为没有 recover，间接抛出 F() 抛过去的异样 a，而后退出。

输入：

bcpanic: agoroutine 1 [running]:main.F()    xxx.go:90 +0x5bmain.G()    xxx.go:82 +0x48main.main()    xxx.go:107 +0x4a5exit status 2

七、

看看上面这段代码的执行程序：

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")}func main() {    G()}

程序如下：

调用 G() 函数；
通过 goroutine 调用 F() 函数；
F() 中遇到 panic，立即终止，不执行 panic 之后的代码；
执行 F() 中 defer 函数，因为没有 recover，则将 panic 抛到 G() 中；
因为 goroutine 外部没有进行 recover，则 goroutine 内部函数，也就是 G() 函数是没方法捕捉的，程序间接解体退出。

输入：

bpanic: agoroutine 6 [running]:main.F()    xxx.go:96 +0x5bcreated by main.G    xxx.go:87 +0x57exit status 2

八、

最初再说一个 recover 的返回值问题：

defer func() {    if err := recover(); err != nil {        fmt.Println("捕捉异样:", err.Error())    }}()panic("a")

recover 返回的是 interface {} 类型，而不是 error 类型，所以这样应用的话会报错：

err.Error undefined (type interface {} is interface with no methods)

能够这样来转换一下：

defer func() {    if err := recover(); err != nil {        fmt.Println("捕捉异样:", fmt.Errorf("%v", err).Error())    }}()panic("a")

或者间接打印后果：

defer func() {    if err := recover(); err != nil {        fmt.Println("捕捉异样:", err)    }}()panic("a")

输入：

捕捉异样: a

以上就是本文的全部内容，其实写过其余的语言的同学都晓得，敞开文件句柄，开释锁等操作是很容易忘的。而 Go 语言通过 defer 很好地解决了这个问题，但在应用过程中还是要小心。

本文总结了一些容踩坑的点，心愿可能帮忙大家少写 BUG，如果大家感觉有用的话，欢送点赞和转发。

文章中的脑图和源码都上传到了 GitHub，有须要的同学可自行下载。

源码地址：

https://github.com/yongxinz/gopher/tree/main/sc

举荐浏览：

gRPC，爆赞
应用 grpcurl 通过命令行拜访 gRPC 服务
举荐三个实用的 Go 开发工具
被 Docker 日志坑惨了

参考：

《Go 语言外围编程》
https://www.jianshu.com/p/63e3d57f285f