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

相关推荐
幼儿园老大*3 小时前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
童先生10 小时前
Go 项目中实现类似 Java Shiro 的权限控制中间件?
开发语言·go
幼儿园老大*11 小时前
走进 Go 语言基础语法
开发语言·后端·学习·golang·go
架构师那点事儿16 小时前
golang 用unsafe 无所畏惧,但使用不得到会panic
架构·go·掘金技术征文
于顾而言1 天前
【笔记】Go Coding In Go Way
后端·go
qq_172805591 天前
GIN 反向代理功能
后端·golang·go
follycat2 天前
2024强网杯Proxy
网络·学习·网络安全·go
OT.Ter2 天前
【力扣打卡系列】单调栈
算法·leetcode·职场和发展·go·单调栈
探索云原生2 天前
GPU 环境搭建指南:如何在裸机、Docker、K8s 等环境中使用 GPU
ai·云原生·kubernetes·go·gpu
OT.Ter2 天前
【力扣打卡系列】移动零(双指针)
算法·leetcode·职场和发展·go