golang 中多個 defer 的執行順序
引用 Ture Go 中的一個示例:
package main
import "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 之前，如下:
func fun() {
id1 := Open()
...
id2 := id1.Open()
...
id2.Close()
id1.Close()
}
如果使用defer，其執行順序和上面完全相同的，所以我們通常在 Open 打開資源后，立即使用 defer Close，不會引起釋放順序問題。
func fun() {
id1 := Open()
defer id1.Close()
...
id2 := id1.Open()
id2.Close()
...
}
defer 壓入棧的是值，如果為函數，則可以修改變量值
func c() (i int) {
defer func() { i++ }()
return 1
}
如上代碼，壓入棧的是一個函數地址，函數執行完后，執行i++,會改變返回值，函數返回值為 2。
從上面的通過defer修改返回值，defer也可以用于控制恢復panic斷言。
package main
import "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的執行順序是倒序執行（同入棧先進后出）
func main() {
defer func() {
fmt.Println("我后出來")
}()
defer func() {
fmt.Println("我先出來")
}()
}
執行后打印出：
我先出來
我后出來
2.defer與return,函數返回值之間的順序
先說結論：return最先執行->return負責將結果寫入返回值中->接著defer開始執行一些收尾工作->最后函數攜帶當前返回值退出
返回值的表達方式，我們知道根據是否提前聲明有兩種方式：一種是func test() int 另一種是 func test() (i int)，所以兩種情況都來說說
func test() int
func 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的時候做的決定。
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后函數的{}中的邏輯
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
}
以上為個人經驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。
您可能感興趣的文章:- Go語言的os包中常用函數初步歸納
- Golang 實現獲取當前函數名稱和文件行號等操作
- Golang 獲取文件md5校驗的方法以及效率對比
- GoLang中生成UUID唯一標識的實現
- Golang全局變量加鎖的問題解決
- go語言基礎 seek光標位置os包的使用
