defer 延迟调用【GO 基础】

〇、前言

在 Go 语言中，defer 是一种用于延迟调用的关键字。

defer 在 Go 语言中的地位非常重要，它是确保资源正确释放和程序健壮性的关键字。

本文将通过示例对其进行专门的详解。

一、defer 简介

defer 的主要用途是在函数执行完毕之前，确保某个操作被执行。

通常用于：资源的释放管理，如关闭文件句柄、释放撕资源、网络连接、数据库连接等。

以下是 defer 的一些关键特性：

• 延迟执行：defer 后的函数调用不会立即执行，而是会推迟到包含它的函数执行结束时才执行
• 逆序执行：如果有多个 defer 语句，它们会按照后进先出的顺序执行，即最后一个被 defer 的语句会最先执行
• 作用域限制：defer 的作用域仅限于包围它的函数，不同于其他语言中的 finally 关键字，后者的作用域在其异常块中
• 语法简洁：在语法上，defer 与普通的函数调用没有区别，但是它提供了一种优雅的方式来确保资源的释放
• 资源管理：defer 常用于确保文件、网络连接等资源在使用完毕后被正确关闭，避免资源泄露。

在实际编程中，合理使用 defer 可以有效地提高代码的可读性和可维护性。下面会进行详细介绍。

二、defer 的使用

2.1 多 defer 时遵循先进后出 FILO

这个不难理解，后面的语句会依赖前面的资源，因此如果先前面的资源先释放了，后面的语句就没法执行了。

下面是一段示例代码，0~4 依次执行 defer，查看输出：

package main

import "fmt"

func main() {
	fmt.Println("begin-------------------!")
	var whatever [5]struct{}
	for i := range whatever {
		defer fmt.Println(i)
	}
	fmt.Println("end---------------------!")
}

输出结果是从 4 开始，说明先运行的 defer 后输出结果，且主线程先运行完成：

  

2.2 defer 与闭包

先解释一下闭包：它是一种编程概念，允许一个函数访问并操作其外部作用域中的变量。闭包通常出现在函数嵌套的情况下，即一个函数内部定义了另一个函数。内部的这个函数能够访问所在函数的变量和参数，无论外部函数已经执行完毕。这种结构使得内部函数保留对外部函数变量的引用，因此这些变量不会被垃圾回收机制收回。

闭包是由函数及其相关的引用环境组合而成的实体，可以理解为函数加上它所引用的外部变量。在Go语言中，所有的闭包都是匿名函数，但不是所有的匿名函数都是闭包。只有当匿名函数捕获了其外部作用域中的变量时，它才成为一个闭包。

官方对 defer 有句解释：

• Each time a "defer" statement executes, the function value and parameters to the call are evaluated as usualand saved anew but the actual function is not invoked.
• 每次执行“defer”语句时，函数值和调用的参数都会像往常一样求值并重新保存，但不会调用实际的函数。

如下一段示例代码，将上一章节的代码 defer 的内容换成一个函数：

package main

import "fmt"

func main() {
	fmt.Println("begin-------------------!")
	var whatever [5]struct{}
	for i := range whatever {
		defer func() { fmt.Println(i) }()
	}
	fmt.Println("end---------------------!")
}

输出结果变成全部为 4，而非 4~0：

  

函数正常执行，由于闭包用到的变量 i 在执行的时候已经变成 4，所以输出全都是 4。

下面将上边示例改良一下，在循环中添加新的变量暂存循环序列值 i：

package main

import "fmt"

func main() {
	fmt.Println("begin-------------------!")
	var whatever [5]struct{}
	for i := range whatever {
		ii := i // 看似多余的赋值，实际上是将公用变量赋值给局部变量
		defer func() { fmt.Println(ii) }()
	}
	fmt.Println("end---------------------!")
}

运行结果：

  

2.3 某个 defer 发生异常，不会影响其他 defer 的正常执行

 如下代码，在 b 和 c 之间的 defer 异常，但不影响 a 和 b 的正常执行：

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

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

如下代码，在 x 声明之后，将其作为参数传入 defer 函数体，此时 x 被赋值，后续的值变化将不会影响 defer 的输出：

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

2.5 大循环时，用和不用 defer 的性能比较

如下代码，声明两个互斥锁，分别加锁和关锁，一个使用 defer 关锁，在循环次数较大时看下耗时情况：

package main

import (
	"fmt"
	"sync"
	"time"
)

var lock sync.Mutex
var lock1 sync.Mutex

func test() {
	lock.Lock()
	lock.Unlock()
}

func testdefer() {
	lock1.Lock()
	defer lock1.Unlock()
}

func main() {
	func() {
		t1 := time.Now()

		for i := 0; i < 1000000; i++ {
			test()
		}
		elapsed := time.Since(t1)
		fmt.Println("test elapsed: ", elapsed)
	}()
	func() {
		t1 := time.Now()

		for i := 0; i < 1000000; i++ {
			testdefer()
		}
		elapsed := time.Since(t1)
		fmt.Println("testdefer elapsed: ", elapsed)
	}()
}

如下图测试结果，在一百万次时，起始差别也不太大：

  

三、defer 陷阱

3.1 执行闭包（Closure）时的特殊取值

一般情况下，defer 执行的代码行，是参数预加载的，也就是取当前行之前的值，之后变量值变化无影响。

但 defer 执行闭包就不一样了，会取之后代码执行完成后变量最终的值。

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

// 执行结果，第三个 defer 能取到后续代码赋值给 err 的异常信息
third defer err divided by zero!
second defer err <nil>
first defer err <nil>

3.2 return 的使用

如下示例，函数 foo() 返回值是整数变量 i，第一次赋值是在 i=0 位置，在最后的 return 时，进行了第二次赋值，defer 执行的闭包是一直监视着变量 i 值的变化：

package main

import "fmt"

func foo() (i int) {

	i = 0

	defer func() {
		fmt.Println("defer-i:", i)
	}()
	fmt.Println("return-before-i:", i)
	return 2
}

func main() {
	foo()
}

// 结果输出，由于 defer 是在全部代码执行完成后（包括 return）才运行
// 因此，defer 最后读取的是 return 赋值给 i 的值 2
return-before-i: 0
defer-i: 2

另外，defer 不可在有 return 分支的后边使用，这样可能造成 defer 为生效，达不到预期效果。这个很好理解，程序走到 return 后，就直接返回了，后边的代码就不再执行了。

3.3 延迟调用的函数为 nil 时引起 panic

如下示例代码，通过 recover() 函数捕捉 panic 信息：

注：recover() 函数的主要作用是在程序发生 panic 时，能够在 defer 语句中捕获到 panic 的信息，并返回导致 panic 的错误值。这样程序可以据此进行相应的处理，而不是直接崩溃退出。

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)
		}
		fmt.Println("end------------!")
	}()
	fmt.Println("start----------!")
	test()
}

// 结果输出，最后的 end 记录可正常输出，说明程序没有异常退出
start----------!
runs
runtime error: invalid memory address or nil pointer dereference
end------------!

3.4 在 for 循环中调用 defer 并非立即执行

如下图中的示例代码，在 for 循环中每次加载 defer，但是并非每次都会执行，而是在 for 循环完成后一块执行：

这些延迟函数会不停地堆积到延迟调用栈中，最终可能会导致一些不可预知的问题。

解决方案有两种，如下：

1）直接在每次循环完成后，去掉 defer 关键字，直接执行 row.Close()：

package main

import (
	"database/sql"
	"fmt"
	"time"

	_ "github.com/denisenkom/go-mssqldb" //  go get github.com/denisenkom/go-mssqldb
)

func main() {
	func() {
		connStr := "server=<服务器地址>;user id=<用户名>;password=<密码>;database=<数据库名>;encrypt=disable"
		// 连接到SQL Server
		db, err := sql.Open("mssql", connStr)
		if err != nil {
			fmt.Println("db,err：", err)
			return
		}
		for {
			row, err := db.Query("select ID,shujubs from tablename where shujubs like '20240328%'")
			if err != nil {
				fmt.Println("row,err:", err)
			}
			row.Close()
		}
	}()
}

2）将 for 内循环体包含在新的函数中，在函数内使用 defer：

package main

import (
	"database/sql"
	"fmt"
	"time"

	_ "github.com/denisenkom/go-mssqldb" //  go get github.com/denisenkom/go-mssqldb
)

func main() {
	func() {
		connStr := "server=<服务器地址>;user id=<用户名>;password=<密码>;database=<数据库名>;encrypt=disable"
		// 连接到SQL Server
		db, err := sql.Open("mssql", connStr)
		if err != nil {
			fmt.Println("db,err：", err)
			return
		}
		for {
			func() {
				row, err := db.Query("select ID,shujubs from tablename where shujubs like '20240328%'")
				if err != nil {
					fmt.Println("row,err:", err)
				}
				defer row.Close() // 函数体中代码执行完后，就会执行 defer
			}()
		}
	}()
}

3.5 在用 {} 包裹的代码块中使用 defer 是没有效果的

首先要知道的是，defer 延迟执行是相对于函数的，而非代码块。

如下代码来测试下，在独立代码块中使用 defer：

package main

import "fmt"

func main() {
	fmt.Println("start----------!")
	{ // 独立代码块
		defer func() {
			fmt.Println("block: defer runs")
		}()

		fmt.Println("block: ends")
	}
	fmt.Println("main: ends")
	fmt.Println("end------------!")
}

如下输出结果，代码块中的 defer 内容，并没有在“main: ends”之前执行：

  

 那么下边来优化下：

package main

import "fmt"

func main() {
	fmt.Println("start----------!")
	func() { // 将独立代码块，改造成函数
		defer func() {
			fmt.Println("block: defer runs")
		}()

		fmt.Println("block: ends")
	}()
	fmt.Println("main: ends")
	fmt.Println("end------------!")
}

 

3.6 使用指针对象作为接收者和不用指针的对比

先看下不用指针的情况：

package main

import "fmt"

type Car struct {
	model string
}

func (c Car) PrintModel() { // 不用指针对象
	fmt.Println(c.model)
}

func main() {
	fmt.Println("start----------!")
	c := Car{model: "DeLorean DMC-12"}
	defer c.PrintModel() // 此时就直接将对象 c 的值保存下来
	c.model = "Chevrolet Impala" // 此处修改对上边已保存的 c 对象无效
	fmt.Println("end------------!")
}

下面用指针对象试试看：

package main

import "fmt"

type Car struct {
	model string
}

func (c *Car) PrintModel() { // 使用指针对象
	fmt.Println(c.model)
}

func main() {
	fmt.Println("start----------!")
	c := Car{model: "DeLorean DMC-12"}
	defer c.PrintModel()         // 这里只保存了对象 c 的物理地址
	c.model = "Chevrolet Impala" // 修改对象 c 后，defer 仍可取最新值
	fmt.Println("end------------!")
}

参考：http://www.topgoer.com/%E5%87%BD%E6%95%B0/%E5%BB%B6%E8%BF%9F%E8%B0%83%E7%94%A8defer.html     https://studygolang.com/articles/12061#commentForm