go语言-深入defer[1]

发表于 2年以前 | 总阅读数：356 次

别摘掉嫩芽，他们的时代才刚刚开始...

defer是Go语言中的关键字，也是Go语言的重要特性之一。defer 语法形式为defer Expression，其后必须紧跟一个函数调用或者方法调用，不能用括号括起来[1]。在很多时候，defer后的函数以匿名函数或闭包的形式呈现，例如：

defer func(...){
 // 实际处理
    }()

defer将其后的函数推迟到了其所在函数返回之前执行。例如在运行如下代码后，将首先打印出下方的"normal func"，接着打印出"defer func"。

func main(){
    defer fmt.Println("defer func")
    fmt.Println("normal func")

不管defer函数后的执行路径如何，最终都将被执行。在Go语言中，defer一般被用于资源的释放及异常panic的处理。

虽然很多语言都具有异常处理和最终处理的功能，例如C++与Java中的try...catch语句，C语言中的析构函数及Java中的finally块。但是，Go语言中的defer有一些不同的特点及灵活性，包括程序中可以有多个defer、defer的调用可以存在于函数的任何位置等。defer可能不会被执行，例如，如果判断条件不成立则放置在if语句中的defer可能不会被执行。defer语句在使用时有许多陷阱， Go语言中defer的实现方式也经历了多次演进。本章将深入介绍defer语句的特性及其背后的原理。

使用的defer的优势

资源释放

defer一般用于资源的释放和异常的捕获，作为Go语言的特性之一，defer给Go代码的书写方式带来了很大的变化。下面的CopyFile函数用于将文件srcName的内容复制到文件dstName中。

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
    written, err = io.Copy(dst, src)
    dst.Close()
    src.Close()
    return
}

在程序最开始，os.Open 及 os.Create 打开了两个文件资源描述符，并在最后通过file.Close得到释放，在正常情况下，该程序能正常运行，一旦在dstName文件创建过程中出现错误，程序将直接返回，src资源将得不到释放。因此需要在所有错误退出时释放资源，即修改为如下代码才能保证其在异常情况下的正确性。

dst, err := os.Create(dstName)
    if err != nil {
                src.Close()
        return
    }
        ...

同样的问题也存在于锁的释放中，一旦在加锁后发生了错误，就需要在每个错误的地方都加锁，否则会出现严重的死锁问题，这也是开发者在C/C++中常犯的错误，特别是在函数中有更多的退出路径以及更多需要释放的资源时。

l.lock()

if err != nil{
    l.unlock()
    return
}
if err != nil{
        l.unlock()
    return
}
...

Go语言中的defer特性能够很好地解决这一类资源释放问题，不管defer后面的执行路径如何，defer中的语句都将会执行。如上的例子可以被修改如下，在每个资源后都立即加入defer file.Close函数 ,保证函数在任意路径执行结束后都能够关闭资源。defer是一种优雅的关闭资源的方式，能减少大量冗余的代码并避免由于忘记释放资源而产生的错误。

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    defer src.Close()
    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
    defer dst.Close()
    return io.Copy(dst, src)
}

10.1.2 异常捕获

程序在运行时可能在任意的地方发生panic异常，例如算术除0错误、内存无效访问、数组越界等，这些错误会导致程序异常退出。在很多时候，我们希望能够捕获这样的错误，同时希望程序能够继续正常执行。一些语言采用try..catch语法，当try块中发生异常时，可以通过catch块捕获。

try{
 //
}catch{
// 异常捕获
}

Go语言使用了特别的方式处理这一问题。defer的特性是无论后续函数的执行路径如何以及是否发生了panic，在函数结束后一定会得到执行，这为异常捕获提供了很好的时机。异常捕获通常结合一起使用。

func executePanic() {
    defer fmt.Println("defer func")
    panic("This is Panic Situation")
    fmt.Println("The function executes Completely")
}
func main() {
    executePanic()
    fmt.Println("Main block is executed completely...")
}

如上所示，在executePanic函数中，手动执行panic触发了异常。当异常触发后，函数仍然会调用defer中的函数，然后异常退出。输出如下，表明调用了defer中的函数，并且main函数将不能正常运行，程序异常退出打印出栈追踪信息。

defer func
panic: This is Panic Situation
goroutine 1 [running]:
main.executePanic()
        /Users/jackson/career/debug-go/tess.go:90 +0x95
main.main()
        /Users/jackson/career/debug-go/tess.go:95 +0x22

如下所示，当在defer函数中使用recover进行异常捕获后，程序将不会异常退出，并且能够执行正常的函数流程。

func executePanic() {
    defer func(){
        if errMsg := recover(); errMsg != nil {
            fmt.Println(errMsg)
        }
        fmt.Println("This is recovery function...")
    }()
    panic("This is Panic Situation")
    fmt.Println("The function executes Completely")
}
func main() {
    executePanic()
    fmt.Println("Main block is executed completely...")
}

如下输出表明，尽管有panic，main函数仍然在正常执行后退出。

<pre style="box-sizing: border-box;-webkit-print-color-adjust: exact;background: rgba(135, 131, 120, 0.15);padding: 1.5em 1em;border-radius: 3px;font-size: 13.6px;tab-size: 2;white-space: pre-wrap;word-break: break-all;font-family: SFMono-Regular, Menlo, Consolas, "PT Mono", "Liberation Mono", Courier, monospace;">```
This is Panic Situation<br></br>This is recovery function...<br></br>Main block is executed completely...