Golang延迟调用：

defer特性：

1. 关键字 defer 用于注册延迟调用。

2. 这些调用直到 return 前才被执。因此，可以用来做资源清理。

3. 多个defer语句，按先进后出的方式执行。

4. defer语句中的变量，在defer声明时就决定了。

defer用途：

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)
    }
}

输出结果：

defer 碰上闭包

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

输出结果：

其实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

看似多此一举的声明

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 {
        t2 := t
        defer t2.Close()
    }
}

输出结果：

    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：

内置函数

假如函数F中书写了panic语句，会终止其后要执行的代码，在panic所在函数F内如果存在要执行的defer函数列表，按照defer的逆序执行

返回函数F的调用者G，在G中，调用函数F语句之后的代码不会执行，假如函数G中存在要执行的defer函数列表，按照defer的逆序执行

直到goroutine整个退出，并报告错误

recover：

1、内置函数

2、用来控制一个goroutine的panicking行为，捕获panic，从而影响应用的行为

3、一般的调用建议

a). 在defer函数中，通过recever来终止一个goroutine的panicking过程，从而恢复正常代码的执行

b). 可以获取通过panic传递的error

注意:

利用recover处理panic指令，defer 必须放在 panic 之前定义，另外 recover 只有在 defer 调用的函数中才有效。否则当panic时，recover无法捕获到panic，无法防止panic扩散。

recover 处理异常后，逻辑并不会恢复到 panic 那个点去，函数跑到 defer 之后的那个点。

多个 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。

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

Golang延迟调用：

defer特性：

defer用途：

go语言 defer

defer 碰上闭包

defer f.Close

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

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

defer陷阱

defer 与 closure

defer 与 return

defer nil 函数

在错误的位置使用 defer

不检查错误

异常处理

panic：

recover：

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

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

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

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

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

Golang延迟调用：

defer特性：

defer用途：

go语言 defer

defer 碰上闭包

defer f.Close

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

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

defer陷阱

defer 与 closure

defer 与 return

defer nil 函数

在错误的位置使用 defer

不检查错误

panic：

recover：

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

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

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

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

热门文章

最新文章

相关课程

相关电子书

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

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