defer实现原理

目录

• 1.前言
• 2. 一些典型示例
• 3. defer规则
  • 3.1 函数返回过程
  • 3.2 对于主函数返回的值时匿名的，或者字面值，defer不会影响返回值
  • 3.3 主函数拥有匿名返回值，返回变量
  • 3.4 主函数拥有具名返回值
• 4. defer实现原理
• 5. 应用
  • 5.1 recover使用误区
  • 5.2 recover 失效条件
• 6. 总结

1.前言

defer语句用于延迟函数的调用， 每次defer会把所在函数压入栈中， 函数在返回前再把延迟函数取出执行。

defer 函数所在的函数称为主函数， defer语句关联的函数称为延迟函数

延迟函数可能有输入参数，这些参数可能来源于定义defer的函数，延迟函数也可能引用主函数用于返回的变量，也就是说延迟函数可能会影响主函数的一些行为。 类似与闭包。

2. 一些典型示例

1. defer 值拷贝

func deferFuncParameter() {
    var aInt = 1

    defer fmt.Println(aInt)  

    aInt = 2
    return
}

输出：

1

说明：延迟函数fmt.Println(aInt)的参数在defer语句出现时就已经确定了，所以无论后面如何修改aInt变量都不会影响延迟函数。

defer时，相当于将aInt 变量值拷贝了一份儿传递进了defer延迟函数中

2. defer 传递主函数指针，会影响主函数的返回值

package main

import "fmt"

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

输出：
10、2、3

延迟函数printArray()的参数在defer语句出现时就已经确定了，即数组的地址，由于延迟函数执行时机是在return语句之前，所以对数组的最终修改值会被打印出来。

3. 延迟函数中操作主函数的返回值

func deferFuncReturn() (result int) {
    i := 1

    defer func() {
       result++
    }()

    return i
}

输出：2

函数的return语句并不是原子的，实际执行分为设置返回值–>ret，defer语句实际执行在返回前，即拥有defer的函数返回过程是：设置返回值–>执行defer–>ret。所以return语句先把result设置为i的值，即1，defer语句中又把result递增1，所以最终返回2。

3. defer规则

1. 延迟函数的参数在defer语句出现时就已经确定下来了

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

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

2. 延迟函数执行按后进先出顺序执行，即先出现的defer最后执行

   设计defer的初衷是简化函数返回时资源清理的动作，资源往往有依赖顺序，比如先申请A资源，再根据A资源申请B资源，根据B资源申请C资源，即申请顺序是:A–>B–>C，释放时往往又要反向进行。这就是把defer设计成LIFO的原因(Later IN,FIRST OUT)--后进先出。

   每申请到一个用完需要释放的资源时，立即定义一个defer来释放资源是个很好的习惯。

3. 延迟函数可能操作主函数的具名返回值

   即主函数可能有返回值，返回值有没有名字没有关系，defer所作用的函数，即延迟函数可能会影响到返回值。

3.1 函数返回过程

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

举个实际的例子进行说明这个过程：

func deferFuncReturn() (result int) {
    i := 1

    defer func() {
       result++
    }()

    return i
}

该函数的return语句可以拆分成下面两行：

result = i
return

而延迟函数的执行正是在return之前，即加入defer后的执行过程如下：

result = i
result++
return

所以上面函数实际返回i++值。

3.2 对于主函数返回的值时匿名的，或者字面值，defer不会影响返回值

字面返回值示例：

func foo() int {
    var i int

    defer func() {
        i++
    }()

    return 1  // 返回的具体的时某个值
}

上面的return语句，直接把1写入栈中作为返回值，延迟函数无法操作该返回值，所以就无法影响返回值。

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

一个主函数拥有一个匿名的返回值，返回使用本地或全局变量，这种情况下defer语句可以引用到返回值，但不会改变返回值。

返回本地变量的函数：

func foo() int {
    var i int

    defer func() {
        i++
    }()

    return i
}

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

anony = i
i++
return

由于i是整型，会将值拷贝给anony，所以defer语句中修改i值，对函数返回值不造成影响。

3.4 主函数拥有具名返回值

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

影响主函数返回值的例子：

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

    return 0
}

函数拆解出来：

ret = 0
ret ++
return 

函数真正返回前，在defer中对返回值做了+1操作，所以函数最终返回1。

4. defer实现原理

源码包src/src/runtime/runtime2.go:_defer定义了defer的数据结构：

type _defer struct {
    sp      uintptr   //函数栈指针
    pc      uintptr   //程序计数器
    fn      *funcval  //函数地址
    link    *_defer   //指向自身结构的指针，用于链接多个defer
}

defer后面一定要接一个函数的，所以defer的数据结构跟一般函数类似，也有栈地址、程序计数器、函数地址等等。

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

展示多个defer被链接的过程:

从上图可以看到，新声明的defer总是添加到链表头部。

一个goroutine可能连续调用多个函数，defer添加过程跟上述流程一致，进入函数时添加defer，离开函数时取出defer，所以即便调用多个函数，也总是能保证defer是按LIFO方式执行的。

5. 应用

项目中， 有时为了让程序更加健壮，即不使用panic， 通常使用recover 来接受异常并处理

比如以下代码：

func NoPanic() {
    if err := recover(); err != nil {
        fmt.Println("Recover success...")
    }
}

func Dived(n int) {
    defer NoPanic()  // defer与panic结合使用

    fmt.Println(1/n)
}

func NoPanic() 会自动接收异常，并打印相关日志，算是一个通用的异常处理函数。

业务处理函数中只要使用了defer NoPanic()，那么就不会再有panic发生

5.1 recover使用误区

在项目中，有众多的数据库更新操作，正常的更新操作需要提交，而失败的就需要回滚，如果异常分支比较多，
就会有很多重复的回滚代码，所以有人尝试了一个做法：即在defer中判断是否出现异常，有异常则回滚，否则提交

代码简化如下:

func IsPanic() bool {
    if err := recover(); err != nil {
        fmt.Println("Recover success...")
        return true
    }

    return false
}

func UpdateTable() {
    // defer中决定提交还是回滚
    defer func() {
        if IsPanic() {
            // Rollback transaction
        } else {
            // Commit transaction
        }
    }()

    // Database update operation...
}

func IsPanic() bool 用来接收异常，返回值用来说明是否发生了异常。func UpdateTable()函数中，使用defer来判断最终应该提交还是回滚。

上面代码初步看起来还算合理，但是此处的IsPanic()再也不会返回true，不是IsPanic()函数的问题，而是其调用的位置不对。

5.2 recover 失效条件

上面代码IsPanic 失效了， 原因是违反了recover的一个限制， 导致recover失效（永远返回的是nil)

以下的三种条件会让recover返回nil:

1. panic时指定参数为nil; (一般panic语句如 panic("xxx failed"))
2. 当前协程没有发生panic;
3. recover没有被defer方法直接调用，可以理解为，recover关键词必须和defer函数出现在同一函数种

而上面的例子正是违反了第三条规则， defer函数和recover关键词没有出现在同一个函数中

所以recover()永远返回nil

6. 总结

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