Go基础：延迟调用defer、异常处理

素颜马尾好姑娘i 2023-07-07 12:47 23阅读 0赞

### Golang延迟调用： ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70][]

## defer特性： ##

>     1. 关键字 defer 用于注册延迟调用。  
>     2. 这些调用直到 return 前才被执。因此，可以用来做资源清理。  
>     3. 多个defer语句，按先进后出的方式执行。  
>     4. defer语句中的变量，在defer声明时就决定了。

## defer用途： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 1][]

>     1. 关闭文件句柄  
>     2. 锁资源释放  
>     3. 数据库连接释放

# go语言 defer #

go 语言的defer功能强大，对于资源管理非常方便，但是如果没用好，也会有陷阱。

defer 是先进后出

这个很自然,后面的语句会依赖前面的资源，因此如果先前面的资源先释放了，后面的语句就没法执行了。

package main
    
    import "fmt"
    
    func main() {
        var whatever [5]struct{}
    
        for i := range whatever {
            defer fmt.Println(i)
        }
    }

输出结果：

4
        3
        2
        1
        0

## defer 碰上闭包 ##

package main
    
    import "fmt"
    
    func main() {
        var whatever [5]struct{}
        for i := range whatever {
            defer func() { fmt.Println(i) }()
        }
    }

输出结果：

4
        4
        4
        4
        4

其实go说的很清楚,我们一起来看看go spec如何说的

我们先看一下官方对`defer`的解释：

> Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usual and saved a new but the actual function is not invoked.
> 
> Instead, deferred functions are invoked immediately before the surrounding function returns, in the reverse order they were deferred. If a deferred function value evaluates to nil, execution panics when the function is invoked, not when the “defer” statement is executed.

翻译一下：

> **每次defer语句执行的时候，会把函数“压栈”**，**函数参数会被拷贝下来**；当外层函数（非代码块，如一个for循环）退出时，defer函数按照定义的逆序执行；如果defer执行的函数为nil, 那么会在最终调用函数的产生panic.
> 
> defer语句并不会马上执行，而是会进入一个栈，函数return前，会按先后出的顺序执行。也说是说最先被定义的defer语句最后执行。先进后出的原因是后面定义的函数可能会依赖前面的资源，自然要先执行；否则，如果前面先执行，那后面函数的依赖就没有了。
> 
> 在defer函数定义时，对外部变量的引用是有两种方式的，分别是作为函数参数和作为闭包引用。
> 
>  *  **作为函数参数，则在defer定义时就把值传递给defer，并被cache起来；**
>  *  **作为闭包引用的话，则会在defer函数真正调用时根据整个上下文确定当前的值。**
> 
> defer后面的语句在执行的时候，函数调用的参数会被保存起来，也就是复制了一份。真正执行的时候，实际上用到的是这个复制的变量，因此如果此变量是一个“值”，那么就和定义的时候是一致的。如果此变量是一个“引用”，那么就可能和定义的时候不一致。

**也就是说函数正常执行,由于闭包用到的变量 i 在执行的时候已经变成4,所以输出全都是4.**

## defer f.Close ##

这个大家用的都很频繁,但是go语言编程举了一个可能一不小心会犯错的例子.

package main
    
    import "fmt"
    
    type Test struct {
        name string
    }
    
    func (t *Test) Close() {
        fmt.Println(t.name, " closed")
    }
    func main() {
        ts := []Test{
       {"a"}, {"b"}, {"c"}}
        for _, t := range ts {
            defer t.Close()
        }
    }

输出结果：

c  closed
        c  closed
        c  closed

这个输出并不会像我们预计的输出c b a,而是输出c c c

可是按照前面的go spec中的说明,应该输出c b a才对啊.

那我们换一种方式来调用一下.

package main
    
    import "fmt"
    
    type Test struct {
        name string
    }
    
    func (t *Test) Close() {
        fmt.Println(t.name, " closed")
    }
    func Close(t Test) {
        t.Close()
    }
    func main() {
        ts := []Test{
       {"a"}, {"b"}, {"c"}}
        for _, t := range ts {
            defer Close(t)
        }
    }

输出结果：

c  closed
        b  closed
        a  closed

这个时候输出的就是c b a

当然,如果你不想多写一个函数,也很简单,可以像下面这样,同样会输出c b a

看似多此一举的声明

输出结果：

c  closed
        b  closed
        a  closed

通过以上例子，结合

> Each time a "defer" statement executes, the function value and parameters to the call are evaluated as usual and saved anew but the actual function is not invoked.

这句话。可以得出下面的结论：

**defer后面的语句在执行的时候，函数调用的参数会被保存起来，但是不执行。**也就是复制了一份。但是并没有说struct这里的this指针如何处理，通过这个例子可以看出go语言并没有把这个明确写出来的this指针当作参数来看待。

**多个 defer 注册，按 FILO 次序执行 ( 先进后出 )。哪怕函数或某个延迟调用发生错误，这些调用依旧会被执行。**

package main
    
    func test(x int) {
        defer println("a")
        defer println("b")
    
        defer func() {
            println(100 / x) // div0 异常未被捕获，逐步往外传递，最终终止进程。
        }()
    
        defer println("c")
    }
    
    func main() {
        test(0)
    }

输出结果:

c
        b
        a
        panic: runtime error: integer divide by zero

## `*`延迟调用参数在注册时求值或复制，可用指针或闭包 "延迟" 读取。 ##

package main
    
    func test() {
        x, y := 10, 20
    
        defer func(i int) {
            println("defer:", i, y) // y 闭包引用
        }(x) // x 被复制
    
        x += 10
        y += 100
        println("x =", x, "y =", y)
    }
    
    func main() {
        test()
    }

输出结果:

x = 20 y = 120
        defer: 10 120

## `*`滥用 defer 可能会导致性能问题，尤其是在一个 "大循环" 里。 ##

package main
    
    import (
        "fmt"
        "sync"
        "time"
    )
    
    var lock sync.Mutex
    
    func test() {
        lock.Lock()
        lock.Unlock()
    }
    
    func testdefer() {
        lock.Lock()
        defer lock.Unlock()
    }
    
    func main() {
        func() {
            t1 := time.Now()
    
            for i := 0; i < 10000; i++ {
                test()
            }
            elapsed := time.Since(t1)
            fmt.Println("test elapsed: ", elapsed)
        }()
        func() {
            t1 := time.Now()
    
            for i := 0; i < 10000; i++ {
                testdefer()
            }
            elapsed := time.Since(t1)
            fmt.Println("testdefer elapsed: ", elapsed)
        }()
    
    }

输出结果:

test elapsed:  223.162µs
        testdefer elapsed:  781.304µs

## defer陷阱 ##

### defer 与 closure ###

package main
    
    import (
        "errors"
        "fmt"
    )
    
    func foo(a, b int) (i int, err error) {
        defer fmt.Printf("first defer err %v\n", err)
        defer func(err error) { fmt.Printf("second defer err %v\n", err) }(err)
        defer func() { fmt.Printf("third defer err %v\n", err) }()
        if b == 0 {
            err = errors.New("divided by zero!")
            return
        }
    
        i = a / b
        return
    }
    
    func main() {
        foo(2, 0)
    }

输出结果：

third defer err divided by zero!
        second defer err <nil>
        first defer err <nil>

> 解释：**如果 defer 后面跟的不是一个 closure 最后执行的时候我们得到的并不是最新的值**。

## defer 与 return ##

package main
    
    import "fmt"
    
    func foo() (i int) {
    
        i = 0
        defer func() {
            fmt.Println(i)
        }()
    
        return 2
    }
    
    func main() {
        foo()
    }

输出结果：

> 解释：在有具名返回值的函数中（这里具名返回值为 i），执行 return 2 的时候实际上已经将 i 的值重新赋值为 2。所以defer closure 输出结果为 2 而不是 1。

## defer nil 函数 ##

package main
    
    import (
    	"fmt"
    )
    
    func test() {
    	var run func() = nil
    	defer run()
    	fmt.Println("runs")
    }
    
    func main() {
    	defer func() {
    		if err := recover(); err != nil {
    			fmt.Println(err)
    		}
    	}()
    	test()
    }

输出结果：

runs
    runtime error: invalid memory address or nil pointer dereference

> 解释：名为 test 的函数一直运行至结束，然后 defer 函数会被执行且会因为值为 nil 而产生 panic 异常。然而值得注意的是，run() 的声明是没有问题，因为在test函数运行完成后它才会被调用。

## 在错误的位置使用 defer ##

当 http.Get 失败时会抛出异常。

package main
    
    import "net/http"
    
    func do() error {
        res, err := http.Get("http://www.google.com")
        defer res.Body.Close()
        if err != nil {
            return err
        }
    
        // ..code...
    
        return nil
    }
    
    func main() {
        do()
    }

输出结果：

panic: runtime error: invalid memory address or nil pointer dereference

> 因为在这里我们并没有检查我们的请求是否成功执行，当它失败的时候，我们访问了 Body 中的空变量 res ，因此会抛出异常

**解决方案**

总是在一次成功的资源分配下面使用 defer ，对于这种情况来说意味着：当且仅当 http.Get 成功执行时才使用 defer

package main
    
    import "net/http"
    
    func do() error {
        res, err := http.Get("http://xxxxxxxxxx")
        if res != nil {
            defer res.Body.Close()
        }
    
        if err != nil {
            return err
        }
    
        // ..code...
    
        return nil
    }
    
    func main() {
        do()
    }

在上述的代码中，当有错误的时候，err 会被返回，否则当整个函数返回的时候，会关闭 res.Body 。

> 解释：在这里，你同样需要检查 res 的值是否为 nil ，这是 http.Get 中的一个警告。
> 
> 通常情况下，出错的时候，返回的内容应为空并且错误会被返回，可当你获得的是一个重定向 error 时， res 的值并不会为 nil ，但其又会将错误返回。上面的代码保证了无论如何 Body 都会被关闭，如果你没有打算使用其中的数据，那么你还需要丢弃已经接收的数据。

## 不检查错误 ##

在这里，f.Close() 可能会返回一个错误，可这个错误会被我们忽略掉

package main
    
    import "os"
    
    func do() error {
        f, err := os.Open("book.txt")
        if err != nil {
            return err
        }
    
        if f != nil {
            defer f.Close()
        }
    
        // ..code...
    
        return nil
    }
    
    func main() {
        do()
    }

改进一下

package main
    
    import "os"
    
    func do() error {
        f, err := os.Open("book.txt")
        if err != nil {
            return err
        }
    
        if f != nil {
            defer func() {
                if err := f.Close(); err != nil {
                    // log etc
                }
            }()
        }
    
        // ..code...
    
        return nil
    }
    
    func main() {
        do()
    }

再改进一下

通过命名的返回变量来返回 defer 内的错误。

package main
    
    import "os"
    
    func do() (err error) {
        f, err := os.Open("book.txt")
        if err != nil {
            return err
        }
    
        if f != nil {
            defer func() {
                if ferr := f.Close(); ferr != nil {
                    err = ferr
                }
            }()
        }
    
        // ..code...
    
        return nil
    }
    
    func main() {
        do()
    }

释放相同的资源

如果你尝试使用相同的变量释放不同的资源，那么这个操作可能无法正常执行。

package main
    
    import (
        "fmt"
        "os"
    )
    
    func do() error {
        f, err := os.Open("book.txt")
        if err != nil {
            return err
        }
        if f != nil {
            defer func() {
                if err := f.Close(); err != nil {
                    fmt.Printf("defer close book.txt err %v\n", err)
                }
            }()
        }
    
        // ..code...
    
        f, err = os.Open("another-book.txt")
        if err != nil {
            return err
        }
        if f != nil {
            defer func() {
                if err := f.Close(); err != nil {
                    fmt.Printf("defer close another-book.txt err %v\n", err)
                }
            }()
        }
    
        return nil
    }
    
    func main() {
        do()
    }

输出结果： defer close book.txt err close ./another-book.txt: file already closed

当延迟函数执行时，只有最后一个变量会被用到，因此，f 变量 会成为最后那个资源 (another-book.txt)。而且两个 defer 都会将这个资源作为最后的资源来关闭

解决方案：

package main
    
    import (
        "fmt"
        "io"
        "os"
    )
    
    func do() error {
        f, err := os.Open("book.txt")
        if err != nil {
            return err
        }
        if f != nil {
            defer func(f io.Closer) {
                if err := f.Close(); err != nil {
                    fmt.Printf("defer close book.txt err %v\n", err)
                }
            }(f)
        }
    
        // ..code...
    
        f, err = os.Open("another-book.txt")
        if err != nil {
            return err
        }
        if f != nil {
            defer func(f io.Closer) {
                if err := f.Close(); err != nil {
                    fmt.Printf("defer close another-book.txt err %v\n", err)
                }
            }(f)
        }
    
        return nil
    }
    
    func main() {
        do()
    }

# 异常处理 #

> Golang 没有结构化异常，使用 panic 抛出错误，recover 捕获错误。

异常的使用场景简单描述：**Go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。**

## panic： ##

> 1.  内置函数
> 2.  假如函数F中书写了panic语句，会终止其后要执行的代码，在panic所在函数F内如果存在要执行的defer函数列表，按照defer的逆序执行
> 3.  返回函数F的调用者G，在G中，调用函数F语句之后的代码不会执行，假如函数G中存在要执行的defer函数列表，按照defer的逆序执行
> 4.  直到goroutine整个退出，并报告错误  
>

## recover： ##

>     1、内置函数  
>     2、用来控制一个goroutine的panicking行为，捕获panic，从而影响应用的行为  
>     3、一般的调用建议  
>         a). 在defer函数中，通过recever来终止一个goroutine的panicking过程，从而恢复正常代码的执行  
>         b). 可以获取通过panic传递的error

注意:

> 1.  利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。
> 2.  **recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。**
> 3.  多个 defer 会形成 defer 栈，后定义的 defer 语句会被最先调用。  
>

package main
    
    func main() {
        test()
    }
    
    func test() {
        defer func() {
            if err := recover(); err != nil {
                println(err.(string)) // 将 interface{} 转型为具体类型。
            }
        }()
    
        panic("panic error!")
    }

输出结果：

panic error!

**由于 panic、recover 参数类型为 interface\{\}，因此可抛出任何类型对象。**

func panic(v interface{})
        func recover() interface{}

## 向已关闭的通道发送数据会引发panic ##

package main
    
    import (
        "fmt"
    )
    
    func main() {
        defer func() {
            if err := recover(); err != nil {
                fmt.Println(err)
            }
        }()
    
        var ch chan int = make(chan int, 10)
        close(ch)
        ch <- 1
    }

输出结果：

send on closed channel

## 延迟调用中引发的错误，可被后续延迟调用捕获，但仅最后一个错误可被捕获。 ##

package main
    
    import "fmt"
    
    func test() {
        defer func() {
            fmt.Println(recover())
        }()
    
        defer func() {
            panic("defer panic")
        }()
    
        panic("test panic")
    }
    
    func main() {
        test()
    }

输出:

defer panic

捕获函数 recover 只有在延迟调用内直接调用才会终止错误，否则总是返回 nil。任何未捕获的错误都会沿调用堆栈向外传递。

package main
    
    import "fmt"
    
    func test() {
        defer func() {
            fmt.Println(recover()) //有效
        }()
        defer recover()              //无效！
        defer fmt.Println(recover()) //无效！
        defer func() {
            func() {
                println("defer inner")
                recover() //无效！
            }()
        }()
    
        panic("test panic")
    }
    
    func main() {
        test()
    }

输出:

defer inner
        <nil>
        test panic

使用延迟匿名函数或下面这样都是有效的。

package main
    
    import (
        "fmt"
    )
    
    func except() {
        fmt.Println(recover())
    }
    
    func test() {
        defer except()
        panic("test panic")
    }
    
    func main() {
        test()
    }

输出结果：

test panic

如果需要保护代码 段，可将代码块重构成匿名函数，如此可确保后续代码被执 。

package main
    
    import "fmt"
    
    func test(x, y int) {
        var z int
    
        func() {
            defer func() {
                if recover() != nil {
                    z = 0
                }
            }()
            panic("test panic")
            z = x / y
            return
        }()
    
        fmt.Printf("x / y = %d\n", z)
    }
    
    func main() {
        test(2, 1)
    }

输出结果：

x / y = 0

除用 panic 引发中断性错误外，还可返回 error 类型错误对象来表示函数调用状态。

type error interface {
        Error() string
    }

标准库 errors.New 和 fmt.Errorf 函数用于创建实现 error 接口的错误对象。通过判断错误对象实例来确定具体错误类型。

package main
    
    import (
        "errors"
        "fmt"
    )
    
    var ErrDivByZero = errors.New("division by zero")
    
    func div(x, y int) (int, error) {
        if y == 0 {
            return 0, ErrDivByZero
        }
        return x / y, nil
    }
    
    func main() {
        defer func() {
            fmt.Println(recover())
        }()
        switch z, err := div(10, 0); err {
        case nil:
            println(z)
        case ErrDivByZero:
            panic(err)
        }
    }

输出结果：

division by zero

## Go实现类似 try catch 的异常处理 ##

package main
    
    import "fmt"
    
    func Try(fun func(), handler func(interface{})) {
        defer func() {
            if err := recover(); err != nil {
                handler(err)
            }
        }()
        fun()
    }
    
    func main() {
        Try(func() {
            panic("test panic")
        }, func(err interface{}) {
            fmt.Println(err)
        })
    }

输出结果：

test panic

## 如何区别使用 panic 和 error 两种方式? ##

> 惯例是:导致关键流程出现不可修复性错误的使用 panic，其他使用 error。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200223223440805.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200223223508541.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZseTkxMDkwNQ==,size_16,color_FFFFFF,t_70