golang 中多个 defer 的执行顺序
引用 Ture Go 中的一个示例:
|
1
2
3
4
5
6
7
8
9
|
package mainimport "fmt"func main() { fmt.Println("counting") for i := 0; i < 10; i++ { defer fmt.Println(i) } fmt.Println("done")} |
程序执行结果为:
counting
done
9
8
7
6
5
4
3
2
1
0
从结果可以看出,defer 的执行可以看做是一个 FILO(First In Last Out) 栈。
在编写程序时，如果遇到下面的执行流程，id1 先获取资源，然后 id2 通过 id1 获取，而 id2 的释放 Close 必须要在 id1 之前，如下:
|
1
2
3
4
5
6
7
8
|
func fun() { id1 := Open() ... id2 := id1.Open() ... id2.Close() id1.Close()} |
如果使用defer，其执行顺序和上面完全相同的，所以我们通常在 Open 打开资源后，立即使用 defer Close，不会引起释放顺序问题。
|
1
2
3
4
5
6
7
8
|
func fun() { id1 := Open() defer id1.Close() ... id2 := id1.Open() id2.Close() ...} |
defer 压入栈的是值，如果为函数，则可以修改变量值
|
1
2
3
4
|
func c() (i int) { defer func() { i++ }() return 1} |
如上代码，压入栈的是一个函数地址，函数执行完后，执行i++,会改变返回值，函数返回值为 2。
从上面的通过defer修改返回值，defer也可以用于控制恢复panic断言。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
package mainimport "fmt"func main() { f() fmt.Println("Returned normally from f.")}func f() { defer func() { if r := recover(); r != nil { fmt.Println("Recovered in f", r) } }() fmt.Println("Calling g.") g(0) fmt.Println("Returned normally from g.")}func g(i int) { if i > 3 { fmt.Println("Panicking!") panic(fmt.Sprintf("%v", i)) } defer fmt.Println("Defer in g", i) fmt.Println("Printing in g", i) g(i + 1)} |
执行结果为:
Calling g.
Printing in g 0
Printing in g 1
Printing in g 2
Printing in g 3
Panicking!
Defer in g 3
Defer in g 2
Defer in g 1
Defer in g 0
Recovered in f 4
Returned normally from f.
补充：Golang中defer的三个实战要点
前言
Golang中的defer是使用频次比较高的，能创造出延迟生效特效的一种方式。
defer也有自己的矫情，需要注意的。
本文将从通过代码的方式来说明defer的三点矫情。
1.defer的生效顺序
2.defer与return,函数返回值之间的顺序
3.defer定义和执行两个步骤，做的事情。
正文
1.defer的生效顺序
先说结论：defer的执行顺序是倒序执行（同入栈先进后出）
|
1
2
3
4
5
6
7
8
|
func main() { defer func() { fmt.Println("我后出来") }() defer func() { fmt.Println("我先出来") }()} |
执行后打印出：
我先出来
我后出来
2.defer与return,函数返回值之间的顺序
先说结论：return最先执行->return负责将结果写入返回值中->接着defer开始执行一些收尾工作->最后函数携带当前返回值退出
返回值的表达方式，我们知道根据是否提前声明有两种方式：一种是func test() int 另一种是 func test() (i int)，所以两种情况都来说说
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
func test() intfunc main() { fmt.Println("main:", test())}func test() int { var i int defer func() { i++ fmt.Println("defer2的值:", i) }() defer func() { i++ fmt.Println("defer1的值:", i) }() return i} |
输出：
defer1的值: 1
defer2的值: 2
main: 0
详解：return的时候已经先将返回值给定义下来了，就是0，由于i是在函数内部声明所以即使在defer中进行了++操作，也不会影响return的时候做的决定。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
func test() (i int)func main() { fmt.Println("main:", test())}func test() (i int) { defer func() { i++ fmt.Println("defer2的值:", i) }() defer func() { i++ fmt.Println("defer1的值:", i) }() return i} |
输出：
defer1的值: 1
defer2的值: 2
main: 2
详解：由于返回值提前声明了，所以在return的时候决定的返回值还是0，但是后面两个defer执行后进行了两次++，将i的值变为2，待defer执行完后，函数将i值进行了返回。
3.defer定义和执行两个步骤，做的事情
先说结论：会先将defer后函数的参数部分的值(或者地址)给先下来【你可以理解为()里头的会先确定】，后面函数执行完，才会执行defer后函数的{}中的逻辑
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
func test(i *int) int { return *i}func main(){ var i = 1 // defer定义的时候test(&i)的值就已经定了，是1，后面就不会变了 defer fmt.Println("i1 =" , test(&i)) i++ // defer定义的时候test(&i)的值就已经定了，是2，后面就不会变了 defer fmt.Println("i2 =" , test(&i)) // defer定义的时候，i就已经确定了是一个指针类型，地址上的值变了，这里跟着变 defer func(i *int) { fmt.Println("i3 =" , *i) }(&i) // defer定义的时候i的值就已经定了，是2，后面就不会变了 defer func(i int) { //defer 在定义的时候就定了 fmt.Println("i4 =" , i) }(i) defer func() { // 地址，所以后续跟着变 var c = &i fmt.Println("i5 =" , *c) }() // 执行了 i=11 后才调用，此时i值已是11 defer func() { fmt.Println("i6 =" , i) }() i = 11} |
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。如有错误或未考虑完全的地方，望不吝赐教。
原文链接：https://blog.csdn.net/robin912/article/details/80739751
