Go语言 defer

引言

Go 语言中的 defer 语句是 UNIX 之父 Ken Thompson 大神发明的，是完全正交的设计。

也正因为 Go 语言遵循的是正交的设计，所以才有了: “少是指数级的多/Less is exponentially more” 的说法。因为是正交的设计，最终得到的组合形式是指数级的组合形式。

作用

在 go 语言中，defer 代码块会在函数调用链表中增加一个函数调用。这个函数调用不是普通的函数调用，而是会在函数正常返回，也就是 return 之后添加一个函数调用。因此，defer 通常用来释放函数内部变量。

通过 defer，我们可以在代码中优雅的关闭/清理代码中所使用的变量。defer 作为 go 语言清理变量的特性，有其独有且明确的行为。

使用规则

当 defer 被声明时，其参数就会被实时解析

func a() {
	i := 0
	defer fmt.Println(i)
	i++
	return
}

结果输出的是0。

通过运行结果，可以看到 defer 输出的值，就是定义时的值。而不是 defer 真正执行时的变量值。

defer 执行顺序为先进后出

当同时定义了多个 defer 代码块时，go 安装先定义后执行的顺序依次调用 defer。我们用下面的代码加深记忆和理解：

func b() {
	for i := 0; i < 4; i++ {
		defer fmt.Print(i)
	}
}

在循环中，依次定义了四个 defe r代码块。结合规则一，我们可以明确得知每个defer代码块应该输出什么值。安装先进后出的原则，我们可以看到依次输出了3210。

defer 可以读取有名返回值

看如下代码：

func c() (i int) {
	defer func() { i++ }()
	return 1
}

输出结果是12。defer 是在 return 调用之后才执行的。这里需要明确的是 defer 代码块的作用域仍然在函数之内，结合上面的函数也就是说，defer 的作用域仍然在 c 函数之内。因此 defer仍然可以读取 c 函数内的变量。

当执行return 1 之后，i的值就是1。此时此刻，defer 代码块开始执行，对 i 进行自增操作。因此输出 2。

使用场景

简化资源的回收

这是最常见的 defer 用法。比如:

mu.Lock()
defer mu.Unlock()

当然, defer 也有一定的开销, 也有为了节省性能而回避使用的 defer 的：

mu.Lock()
count++
mu.Unlock()

从简化资源的释放角度看, defer 类似一个语法糖, 好像不是必须的。

panic 异常的捕获

defer 除了用于简化资源的释放外, 还是 Go 语言异常框架的一个组成部分。 Go 语言中, panic 用于抛出异常, recover 用于捕获异常。recover只能在defer语句中使用, 直接调用recover是无效的。

比如：

func main() {
    f()
    fmt.Println("Returned normally from f.")
}

func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
    fmt.Println("Calling g.")
    g()
    fmt.Println("Returned normally from g.")
}

func g() {
    panic("ERROR")
}

修改返回值

defer 除了用于配合 recover，用于捕获 panic 异常外，defer还可以用于在 return 之后修改函数的返回值。

func doubleSum(a, b int) (sum int) {
    defer func() {   //该函数在函数返回时  调用
        sum *= 2
    }()
    sum = a + b
}

安全的回收资源

前面第一点提到， defer 最常见的用法是简化资源的回收。而且，从资源回收角度看，defer 只是一个语法糖。

其实,，也不完全是这样,，特别是在涉及到第二点提到的 panic 异常等因素导致 goroutine 提前退出时。

比如,，有一个线程安全的 slice 修改函数，为了性能没有使用 defer 语句：

func set(mu *sync.Mutex, arr []int, i, v int) {
    mu.Lock()
    arr[i] = v
    mu.Unlock()
}

但是, 如果 i >= len(arr) 的话,，runtime 就会抛出切片越界的异常（这里只是举例, 实际开发中不应该出现切片越界异常）。这样的话，mu.Unlock() 就没有机会被执行了。

如果用 defer 的话，即使出现异常也能保证 mu.Unlock() 被调用：

func set(mu *sync.Mutex, arr []int, i, v int) {
    mu.Lock()
    defer mu.Unlock()
    arr[i] = v
}

当然，Go 语言约定异常不会跨越 package 边界。因此，调用一般函数的时候不用担心 goroutine 异常退出的情况。

实例

一个例子：

func CopyFile(dst, src string) (w int64, err error) {
 srcFile, err := os.Open(src)
 if err != nil {
  return
 }
 defer srcFile.Close() //每次申请资源时，请习惯立即申请一个 defer 关闭资源，这样就不会忘记释放资源了
 dstFile, err := os.Create(dst)
 if err != nil {
  return
 }
 defer dstFile.Close()

 return io.Copy(dstFile, srcFile)
}

defer 还有一个重要的特性，就是即便函数抛出了异常，也会被执行的。这样就不会因程序出现了错误，而导致资源不会释放了。

参考文章

https://studygolang.com/articles/10167
https://studygolang.com/articles/5932

引言

作用