Golang Defer详解

转载

王小酸 2020-09-21 14:06:19 博主文章分类：Golang

在用Golang开发的时候，defer这个语法也是必备的知识，但是我们除了知道他是在一个函数退出之前执行，对于defer是否还有其他地方需要注意的呢。本文整理的defer的全场景使用情况，部分场景源自网络，加上自己的额外观点和分析，完成了这份defer的7个隐性必备知识点。提纲

知识点1：defer的执行顺序

知识点2: defer与return谁先谁后

知识点3：函数的返回值初始化与defer间接影响

知识点4：有名函数返回值遇见defer情况

知识点5：defer遇见panic

知识点6：defer中包含panic

知识点7：defer下的函数参数包含子函数

知识点1：defer的执行顺序

多个defer出现的时候，它是一个“栈”的关系，也就是先进后出。一个函数中，写在前面的defer会比写在后面的defer调用的晚。

示例代码 package main

import "fmt"

func main() { defer func1() defer func2() defer func3() }

func func1() { fmt.Println("A") }

func func2() { fmt.Println("B") }

func func3() { fmt.Println("C") }

输出结果：

C B A

知识点2: defer与return谁先谁后示例代码 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 结论为：return之后的语句先执行，defer后的语句后执行

知识点3：函数的返回值初始化该知识点不属于defer本身，但是调用的场景却与defer有联系，所以也算是defer必备了解的知识点之一。如： func DeferFunc1(i int) (t int) {} 其中返回值t int，这个t会在函数起始处被初始化为对应类型的零值并且作用域为整个函数。

示例代码 package main

import "fmt"

func DeferFunc(i int) (t int) {

fmt.Println("t = ", t)

return 2

}

func main() { DeferFunc(10) } 结果

t = 0 证明，只要声明函数的返回值变量名称，就会在函数初始化时候为之赋值为0，而且在函数体作用域可见。

知识点4: 有名函数返回值遇见defer情况

在没有defer的情况下，其实函数的返回就是与return一致的，但是有了defer就不一样了。

我们通过知识点2得知，先return，再defer，所以在执行完return之后，还要再执行defer里的语句，依然可以修改本应该返回的结果。

package main

import "fmt"

func returnButDefer() (t int) { //t初始化0，并且作用域为该函数全域

defer func() {
    t = t * 10
}()

return 1

}

func main() { fmt.Println(returnButDefer()) } 该returnButDefer()本应的返回值是1，但是在return之后，又被defer的匿名func函数执行，所以t=t*10被执行，最后returnButDefer()返回给上层main()的结果为10

$ go run test.go 10

知识点5: defer遇见panic

我们知道，能够触发defer的是遇见return(或函数体到末尾)和遇见panic。

根据知识点2，defer遇见return情况如下：

那么，遇到panic时，遍历本协程的defer链表，并执行defer。在执行defer过程中:遇到recover则停止panic，返回recover处继续往下执行。如果没有遇到recover，遍历完本协程的defer链表后，向stderr抛出panic信息。

A. defer遇见panic，但是并不捕获异常的情况 package main

import ( "fmt" )

func main() { defer_call()

fmt.Println("main 正常结束")

}

func defer_call() { defer func() { fmt.Println("defer: panic 之前1") }() defer func() { fmt.Println("defer: panic 之前2") }()

panic("异常内容")  //触发defer出栈

defer func() { fmt.Println("defer: panic 之后，永远执行不到") }()

} 结果

defer: panic 之前2 defer: panic 之前1 panic: 异常内容 //... 异常堆栈信息 B. defer遇见panic，并捕获异常 package main

import ( "fmt" )

func main() { defer_call()

fmt.Println("main 正常结束")

}

func defer_call() {

defer func() {
    fmt.Println("defer: panic 之前1, 捕获异常")
    if err := recover(); err != nil {
        fmt.Println(err)
    }
}()

defer func() { fmt.Println("defer: panic 之前2, 不捕获") }()

panic("异常内容")  //触发defer出栈

defer func() { fmt.Println("defer: panic 之后, 永远执行不到") }()

} 结果

defer: panic 之前2, 不捕获 defer: panic 之前1, 捕获异常异常内容 main 正常结束 defer 最大的功能是 panic 后依然有效所以defer可以保证你的一些资源一定会被关闭，从而避免一些异常出现的问题。

知识点6: defer中包含panic

编译执行下面代码会出现什么? package main

import ( "fmt" )

func main() {

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

defer func() {
    panic("defer panic")
}()

panic("panic")

} 结果

defer panic 分析

panic仅有最后一个可以被revover捕获。

触发panic("panic")后defer顺序出栈执行，第一个被执行的defer中会有panic("defer panic")异常语句，这个异常将会覆盖掉main中的异常panic("panic")，最后这个异常被第二个执行的defer捕获到。

知识点7: 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)) } 这里，有4个函数，他们的index序号分别为1，2，3，4。

那么这4个函数的先后执行顺序是什么呢？这里面有两个defer，所以defer一共会压栈两次，先进栈1，后进栈2。那么在压栈function1的时候，需要连同函数地址、函数形参一同进栈，那么为了得到function1的第二个参数的结果，所以就需要先执行function3将第二个参数算出，那么function3就被第一个执行。同理压栈function2，就需要执行function4算出function2第二个参数的值。然后函数结束，先出栈fuction2、再出栈function1.

所以顺序如下：

defer压栈function1

压栈函数地址、形参1、形参2(调用function3) --> 打印3

defer压栈function2

压栈函数地址、形参1、形参2(调用function4) --> 打印4

defer出栈function2

调用function2 --> 打印2

defer出栈function1

调用function1--> 打印1

3 4 2 1

练习：defer面试真题

了解以上7个defer的知识点，我们来验证一下网上的真题吧。

下面代码输出什么？

package main

import "fmt"

func DeferFunc1(i int) (t int) { t = i defer func() { t += 3 }() return t }

func DeferFunc2(i int) int { t := i defer func() { t += 3 }() return t }

func DeferFunc3(i int) (t int) { defer func() { t += i }() return 2 }

func DeferFunc4() (t int) { defer func(i int) { fmt.Println(i) fmt.Println(t) }(t) t = 1 return 2 }

func main() { fmt.Println(DeferFunc1(1)) fmt.Println(DeferFunc2(1)) fmt.Println(DeferFunc3(1)) DeferFunc4() } 练习题分析 DeferFunc1 func DeferFunc1(i int) (t int) { t = i defer func() { t += 3 }() return t } 将返回值t赋值为传入的i，此时t为1

执行return语句将t赋值给t（等于啥也没做）

执行defer方法，将t + 3 = 4

函数返回 4 因为t的作用域为整个函数所以修改有效。

DeferFunc2 func DeferFunc2(i int) int { t := i defer func() { t += 3 }() return t } 创建变量t并赋值为1

执行return语句，注意这里是将t赋值给返回值，此时返回值为1（这个返回值并不是t）

执行defer方法，将t + 3 = 4

函数返回返回值1

也可以按照如下代码理解

func DeferFunc2(i int) (result int) { t := i defer func() { t += 3 }() return t } 上面的代码return的时候相当于将t赋值给了result，当defer修改了t的值之后，对result是不会造成影响的。

DeferFunc3 func DeferFunc3(i int) (t int) { defer func() { t += i }() return 2 } 首先执行return将返回值t赋值为2

执行defer方法将t + 1

最后返回 3