defer - Go 语言

前言
defer是什么 ★
多个defer的执行顺序 ★
defer和return的顺序 ★
defer和panic
总结

前言

defer是golang中用的比较多的一个关键字，也是go面试题里经常出现的问题，而在很多时候我们只知其然，而不知其所以然，今天就来整理一下关于defer的学习使用，希望对需要的朋友有所帮助。

defer是什么 ★

defer是go中一种延迟调用机制，defer后面的函数只有在当前函数执行完毕后才能执行，将延迟的语句按defer的逆序进行执行，也就是说先被defer的语句最后被执行，最后被defer的语句，最先被执行，通常用于释放资源。
定义：

defer function([parameter_list]) // 延迟执行函数
defer method([parameter_list]) // 延迟执行方法

多个defer的执行顺序 ★

多个defer出现的时候，它会把defer之后的函数压入一个栈中延迟执行，也就是先进后出(LIFO)，写在前面的defer会比写在后面的defer调用的晚。

下面通过一个示例看一下：

func func1(){
    fmt.Println("我是 func1")
}
func func2(){
    fmt.Println("我是 func2")
}
func func3(){
    fmt.Println("我是 func3")
}

func main(){

    defer func1()
    defer func2()
    defer func3()

    fmt.Println("main1")
    fmt.Println("main2")
}

执行输出如下：

main1
main2
我是 func3
我是 func2
我是 func1

通过图示一看就很明白了
defer - 图1

延迟函数的参数在defer声明时就决定了：

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

此时输出的值是0，而不是1，因为defer后面的函数在入栈的时候保存的是入栈那一刻的值，而当时i的值是0，所以后期对i进行修改，并不会影响栈内函数的值。

如果我们把参数传引用：

func main(){
   i:= 0
   defer func(a *int) {
        fmt.Println(*a)
    }(&i)
    i++
}

此时输出的值是1，因为这里defer后面函数入栈的时候，传入的执行变量i的指针，后期i值改变的时候，输出结果也会改变。

defer和return的顺序 ★

首先看下defer和return语句的区别，如下：
defer - 图2
可以看到 return 执行的时候，并不是原子性操作，一般是分为两步:将结果x赋值给了返回值，然后执行了RET指令；而defer语句执行的时候，是在赋值变量之后，在RET指令之前。所以这里注意一下，返回值和x的关系。如果x是一个值类型，这里是进行了拷贝的。
示例：

package main

import "fmt"

func deferFunc() int {
    fmt.Println("defer func called")
    return 0
}

func returnFunc() int {
    fmt.Println("return func called")
    return 0
}

func returnAndDefer() int {

    defer deferFunc()

    return returnFunc()
}

func main() {
    returnAndDefer()
}

执行结果为：

return func called
defer func called

defer和panic

当函数遇到panic，defer仍然会被执行。Go会先执行所有的defer链表(该函数的所有defer)，当所有defer被执行完毕且没有recover时，才会进行panic。
defer 最大的功能是 panic 后依然有效，所以defer可以保证你的一些资源一定会被关闭，从而避免一些异常出现的问题。

package main

import "fmt"

func main() {

    deferPanic()
}

func deferPanic() {

    defer fmt.Println("defer 1")
    defer fmt.Println("defer 2")
    defer fmt.Println("defer 3")

    panic("出错啦")
}

执行输出如下：

defer 3
defer 2
defer 1
panic: 出错啦

我们可以在defer中进行recover，如果defer中包含recover，则程序将不会再进行panic，这就实现了Go中异常抛出/捕获类似的机制。

package main

import (
    "fmt"
)

func main()  {

    defer func() {
        //捕获异常
       if err := recover(); err != nil{
           fmt.Println(err)
       }else {
           fmt.Println("fatal")
       }
    }()

    //抛出异常
    panic("panic")
}

defer下的函数参数包含子函数

package main

import "fmt"

func function(index int, value int) int {

    fmt.Println(index)

    return index
}

func main() {
    defer function(1, function(3, 0))
    defer function(2, function(4, 0))

这个程序的执行结果是怎么样的的？
首先两个defer会压栈两次，先进栈1，后进栈2，在压栈function1的时候，需要连同函数地址、函数形参一同进栈，那么为了得到function1的第二个参数的结果，需要先执行function3将第二个参数算出，所以function3就被第一个执行。同理压入栈function2，就需要先执行function4算出function2的第二个参数的值，然后函数结束，先出栈function2、再出栈function1。输出结果如下：

总结

defer是go中一种延迟调用机制，defer后面的函数只有在当前函数执行完毕后才能执行。
多个defer出现的时候，它会把defer之后的函数压入一个栈中延迟执行，也就是先进后出。
defer后面的函数值在入栈的时候就决定了。
defer 最大的功能是 panic 后依然有效,我们可以在defer中进行recover，如果defer中包含recover，则程序将不会再进行panic，实现try catch机制。

作者：我是一只鱼吖
链接：https://juejin.cn/post/7145728803896033311
状态：已整理