go底层系列-defer原理剖析

go底层系列-defer原理剖析

defer

前言

• defer语句
  • 用于延迟函数的调用
  • 每次defer都会把一个函数压入栈中
  • 函数返回前再把延迟的函数取出并执行
• 我们把创建defer的函数称为主函数
• defer语句后面的函数称为延迟函数
  • 延迟函数可能有输入参数
    • 参数可能来源于定义defer的函数
  • 延迟函数也可能引用主函数用于返回的变量
    • 也 就是说延迟函数可能会影响主函数的一些行为
  • 这些场景下，如果不了解defer的规则很容易出错

热身

// 下面函数输出结果是什么？
func deferFuncParameter()  {
	var aInt = 1

	defer fmt.Println(aInt)

	aInt = 2
	return
}

func main() {
	deferFuncParameter()
}
// 题目说明：
// 		函数deferFuncParameter()定义一个整型变量并初始化为1，
//		然后使用defer语句打印出变量值，最后修改变量值为2
// 参考答案：
// 		输出1。
//		延迟函数fmt.Println(aInt)的参数在defer语句出现时就已经确定了(这句话是关键)
//		所以无论后面如何修改aInt变量都不会影响延迟函数



// 下面程序输出什么？
func printArray(array *[3]int)  {
	for i := range array {
		fmt.Println(array[i])
	}
}

func deferFuncParameter()  {
	var aArray = [3]int{1, 2, 3}

	defer printArray(&aArray)

	aArray[0] = 10
	return
}

func main() {
	deferFuncParameter()
}
// 函数说明：
//		函数deferFuncParameter()定义一个数组，通过defer延迟函数printArray()的调用，
// 		最后修改数组第一个元素。printArray()函数接受数组的指针并把数组全部打印出来
// 参考答案：
// 		输出10、2、3三个值。延迟函数printArray()的参数在defer语句出现时就已经确定了，即数组的地址
//		由于延迟函数执行时机是在return语句之前(这句是关键)
//		所以对数组的最终修改值会被打印出来



// 下面函数输出什么？
func deferFuncReturn() (result int) {
	i := 1

	defer func() {
		result ++
	}()

	return i
}

func main() {
	fmt.Println(deferFuncReturn())
}
// 函数说明：
// 		函数拥有一个具名返回值result，函数内部声明一个变量i，
//		defer指定一个延迟函数，最后返回变量i。延迟函数中递增result
// 参考答案：
//		函数输出2。
//		函数的return语句并不是原子的，
//		实际执行分为：设置返回值—>ret，
//		defer语句实际执行在返回前，即拥有defer的函数返回过程是：设置返回值—>执行defer—>ret。
//		所以return语句先把result设置为i的值，即1，defer语句中又把result递增1，所以最终返回2

defer规则

规则一：延迟函数的参数在defer语句出现时就已经确定下来了

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

// defer语句中的fmt.Println()参数i值在defer出现时就已经确定下来
// 实际上是拷贝了一份。
// 后面对变量i的修改不会影响fmt.Println()函数的执行，仍然打印”0”。

// 注意：对于指针类型参数，规则仍然适用
// 		只不过延迟函数的参数是一个地址值
// 这种情况下
// 		defer后面的语句对变量的修改可能会影响延迟函数

规则二：延迟函数执行按后进先出顺序执行，即先出现的 defer最后执行

• 这个规则很好理解，定义defer类似于入栈操作，执行defer类似于出栈操作
• 设计defer的初衷是简化函数返回时资源清理的动作
• 资源往往有依赖顺序
  • 比如先申请A资源，再跟据A资源申请B资 源，跟据B资源申请C资源
  • 即申请顺序是:A—>B—>C
  • 释放时往往又要反向进行。这就是把defer设计成FIFO的原因.
  • 每申请到一个用完需要释放的资源时，立即定义一个defer来释放资源是个很好的习惯。

规则三：延迟函数可能操作主函数的具名返回值

• 定义defer的函数，即主函数可能有返回值
• 返回值有没有名字没有关系，defer所作用的函数，即延迟函数可能会影响到返回值。
• 若要理解延迟函数是如何影响主函数返回值的，只要明白函数是如何返回的就足够了。

函数返回过程

• 关键字return不是一个原子操作
• 实际上return只代理汇编指令ret，即将跳转程序执行
  • 比如语句 return i
  • 实际上分两步进行
    • 将i值存入栈中作为返回值
    • 然后执行跳转
  • 而defer的执行时机正是跳转前
  • 所以defer执行时还是有机会操作返回值的

举个实际的例子:

func deferFuncReturn() (result int) {
	i := 1
	
	defer func() {
		result ++
	}()
	
	return i
}
// 该函数的return语句可以拆分成下面两行：
result = i
return

主函数拥有匿名返回值，返回字面值

• 一个主函数拥有一个匿名的返回值，返回时使用字面值
  • 比如返回”1”、”2”、”Hello”这样的值
• 这种情况下defer 语句是无法操作返回值的

func foo() int {
    var i int
    
    defer func() {
        i ++
    }()
    
    return 1
}
// 上面的return语句，直接把1写入栈中作为返回值，延迟函数无法操作该返回值，所以就无法影响返回值。

主函数拥有匿名返回值，返回变量

• 一个主函数拥有一个匿名的返回值，返回使用本地或全局变量
  • defer语句可以引用到返回值
  • 但不会改变返回值。
• 下面的返回值哪怕是指针类型也不行

func foo() int {
	var i int

	defer func() {
		i ++
		fmt.Println(i)
	}()

	return i
}
// 上面的函数，返回一个局部变量，同时defer函数也会操作这个局部变量。
// 对于匿名返回值来说
// 		可以假定仍然有一个变量存储返回值
//		假定返回值变量为”anony”
//		上面的返回语句可以拆分成以下过程：
annoy = i
i ++
return annoy

主函数拥有具名返回值

• 主函声明语句中带名字的返回值，会被初始化成一个局部变量
• 函数内部可以像使用局部变量一样使用该返回值
  • 如果defer语句操作该返回值
  • 可能会改变返回结果。

func foo() (ret int) {
	defer func() {
		ret ++
	}()

	return 0
}
// 上面的函数拆解出来，如下所示
ret = 0
ret ++
return

defer 实现原理

defer 数据结构

• defer后面一定要接一个函数，所以defer的数据结构跟一般函数类似

• 也有栈地址、程序计数器、函数地址等等。

• 与函数不同的一点

  • 它含有一个指针，可用于指向另一个defer
  • 每个goroutine数据结构中实际上也有一个defer 指针
    • 该指针指向一个defer的单链表
    • 每次声明一个defer时，就将defer插入到单链表表头
    • 每次执行defer时，就从单链表表头取出一个defer执行

• 一个goroutine可能连续调用多个函数

• defer添加过程跟上述流程一致

  • 进入函数时添加defer
  • 离开函数时取出 defer

• 所以即便调用多个函数，也总是能保证defer是按FIFO方式执行的

defer的创建和执行

• 源码包 src/runtime/panic.go 定义了两个方法分别用于创建和执行defer
  • deferproc()： 在声明defer处调用，其将defer函数存入goroutine的链表中
  • deferreturn()：在return指令，准确的讲是在ret指令前调用
    • 其将defer从goroutine链表中取出并执行
    • 可以简单这么理解，在编译在阶段
      • 声明defer处插入了函数deferproc()
      • 在函数return前插入了函数 deferreturn()。

总结

• defer定义的延迟函数参数在defer语句出时就已经确定
• defer定义顺序与实际执行顺序相反
• return不是原子操作
  • 执行过程是: 保存返回值(若有)—>执行defer（若有）—>执行ret跳转
• 申请资源后立即使用defer关闭资源是好习惯