编程宝库 - 技术改变世界

编程宝库

Search

Go编程知识

Go开源项目分布式唯一ID生成系统

grpcurl通过命令行访问gRPC服务

Go程序员踩过的defer坑错误处理

前言

先声明：我被坑过。

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

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

所以，面对这种情况，我们今天就不讲道理了。直接把我珍藏多年的代码一把梭，凭借多年踩坑经历和写 BUG 经验，我要站着把这个坑迈过去。

一、简单的例子

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

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

输出：

done
second
first

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

二、一定不要在for循环中使用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 main
import (
    "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 =  1
b =  5
c =  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=0
e=0

返回值符合预期，再也不用绞尽脑汁猜了。

四、defer表达式的函数如果在panic后面，则这个函数无法被执行。

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

输出如下，b没有打印出来。

panic: a
goroutine 1 [running]:
main.main()
    xxx.go:87 +0x4ce
exit status 2

而如果defer在前，则可以执行。

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

输出：

b
panic: a
goroutine 1 [running]:
main.main()
    xxx.go:90 +0x4e7
exit 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函数。

输出：

捕获异常:a
b
继续执行
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
捕获异常:a
c

六、函数执行顺序

看看下面这段代码的执行顺序：

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，然后退出。

输出：

b
c
panic:a
goroutine1[running]:
main.F()
xxx.go:90+0x5b
main.G()
xxx.go:82+0x48
main.main()
xxx.go:107+0x4a5
exitstatus2

七、外部函数捕获异常执行顺序

看看下面这段代码的执行顺序：

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()函数是没办法捕获的，程序直接崩溃退出。

输出：

b
panic:a
goroutine6[running]:
main.F()
xxx.go:96+0x5b
createdbymain.G
xxx.go:87+0x57
exitstatus2

八、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很好地解决了这个问题，但在使用过程中还是要小心。

源码地址：https://github.com/yongxinz/gopher/tree/main/sc

以上就是Go程序员踩过的defer坑错误处理的详细内容，更多关于Go defer错误处理的资料请关注编程宝库其它相关文章！

下一节：grpcurl通过命令行访问gRPC服务

Go编程技术

前言一般情况下测试 gRPC 服务，都是通过客户端来直接请求服务端。如果客户端还没准备好的话，也可以使用 BloomRPC 这样的 GUI 客户端。如果环境不支持安装这种 GUI 客户端 ...

Go开源项目分布式唯一ID生成系统

grpcurl通过命令行访问gRPC服务