go語言 defer 高階

go語言defer語句的用法

defer後面必須是函式呼叫語句，不能是其他語句，否則編譯器會出錯。

package main
import "log"
func foo(n int) int 
func main()

這個例子中defer後面使用的是n++指令，不是乙個函式呼叫語句，編譯器就報錯：

# command-line-arguments
./main.go:6: expression in defer must be function call
./main.go:6: syntax error: unexpected ++ at end of statement

defer後面的函式在defer語句所在的函式執行結束的時候會被呼叫；我們檢視一下彙編嗎，看看defer是在什麼時候被執行的：

定義兩個函式foo1和foo2，功能和**都是一樣，只是其中乙個包含defer語句，另乙個沒有。

func foo1(i int) int 
func foo2(i int) int

這是foo1的彙編**：

func foo1(i int) int

再看foo2的彙編**：

func foo2(i int) int

通過比較很容易看出foo2有兩處需要注意，第一處是defer foo()語句的翻譯，這個翻譯我沒有細看懂，我猜是準備foo的函式引數(如果有)，然後儲存這些引數值和foo的位址，註冊到系統(runtime.deferproc)；另一處是return指令的翻譯，return指令的執行分三步，第一步拷貝return值到返回值記憶體位址，第二步會呼叫runtime.deferreturn去執行前面註冊的defer函式，第三部再執行ret彙編指令。

有兩個常見的defer語句應用場景是：

func copyfile(dstname, srcname string) (written int64, err error) 
defer src.close()
dst, err := os.create(dstname)
if err != nil 
defer dst.close()
// other codes
return io.copy(dst, src)
}

在開啟輸入檔案輸出檔案後，不管後面的**流程如何影響，這兩個檔案能夠被自動關閉。

func foo(...)

確保mu鎖能夠在函式foo退出之後自動釋放。

我們注意到defer函式的執行是在defer指令所在函式的執行結束之後，那麼如何才能在所在函式的中間就釋放呢，比如前面例子，在foo入口鎖住了lock，而如果foo後半段的**執行時間比較長，而此時又不需要繼續保持住鎖，該怎麼辦呢？

func foo() 
// time-consuming operating with object
...}

我們希望能在time-consuming operation 之前就釋放鎖，而不是等到整個foo返回。這有兩個辦法，乙個是根據邏輯，把foo拆分兩部分，前半部分需要鎖，後半部分不需要鎖；另乙個辦法是使用匿名函式：

package main
import "log"
import "time"
import "sync"
var mu sync.mutex
func lock() 
func unlock() 
func foo() int ()
time.sleep(1 * time.second)
log.printf("return")
return 0;
}func main()

執行結果：

$ ./main 2017/09/30 22:18:58 lock 2017/09/30 22:18:58 inner 2017/09/30 22:18:58 unlock 2017/09/30 22:18:59 return 2017/09/30 22:18:59 r= 0

從日誌我們可以看出mu鎖在sleep語句之前已經被釋放了，而不是需要等到foo函式結束的時候才釋放。

如果函式裡面有多條defer指令，他們的執行順序是反序，即後定義的defer先執行。

package main
import "log"
import "time"
func foo(n int) int 
func main()

執行結果如下，可以看出他們的呼叫順序：

2017/09/30 19:22:03 3333 2017/09/30 19:22:03 2222

2017/09/30 19:22:03 1111

defer函式的引數是在defer語句出現的位置做計算的，而不是在函式執行的時候做計算的，即所在函式結束的時候計算的。

package main
import "log"
func foo(n int) int 
func main()

其執行結果是：

2017/09/30 19:25:10 n1= 100
2017/09/30 19:25:10 n2= 200
2017/09/30 19:25:10 n= 100

可以看到defer函式的位置時n的值為100，儘管在函式foo結束的時候n的值已經是200了，但是defer語句本身所處的位置時刻，即foo函式入口時n為100，所以最終defer函式列印出來的n值為100。

前面我們提到defer後面只能是一條函式呼叫指令；而實際情況下經常會需要邏輯執行，會有分支，條件，而不是簡單的乙個log.print指令；那怎麼處理這種情況呢，我們可以把這些邏輯指令一起定義成乙個函式，然後再呼叫這些函式就行了，命名函式或者匿名函式都可以，下面是乙個匿名函式的例子：

package main
import "log"
import _ "time"
func foo(n int) int ()
n += 100
log.println("n2=", n)
return n
}func main()

執行結果：

2017/09/30 19:30:58 n1= 100
2017/09/30 19:30:58 n2= 200
2017/09/30 19:30:58 n= 300

眼尖的同學會發現其中的問題；為什麼n列印出來是300呢，不是明明說好defer函式的引數值在它出現時候計算，而不是在執行的時候計算的嗎，n應該列印出200才對啊？

同學，仔細看一下原文：defer函式的引數在defer語句出現的位置計算，不是在defer函式執行的時刻計算；人家明明說的很清楚，defer函式的引數，請問這裡n是引數嗎，不是哎，這裡引用的是宿主函式的區域性變數，而不是引數；所以它拿到的是執行時刻的值。

這就引發出下乙個注意事項。

package main
import "log"
func foo1(i *int) int ()
log.printf("i=%d", *i)
return *i
}func foo2(i *int) (r int) ()
log.printf("i=%d", *i)
return *i
}func main()

執行結果為：

$ go build main.go && ./main 
2017/09/30 20:01:00 i=100
2017/09/30 20:01:00 i=300, r=100
2017/09/30 20:01:00 i=100
2017/09/30 20:01:00 i=100, r=300

這個例子其實有一點拗口的。

foo1 return指令前(i==100, ret==0)，return指令後(i==100, ret=100)，然後呼叫defer函式後(i==300，r==100)，defer函式增加了i；main函式收到(i==300, r==100)

foo2 return指令前(i==100, ret==0)，return指令後(i==100, ret=100)，然後呼叫defer函式後(i==100，r==300)，defer函式增加了ret；main函式收到(i==100, r==300)

go語言 defer 高階

go語言 defer 高階

Go語言defer學習小結

go語言defer的使用

go語言 defer 高階

go語言 defer 高階

Go語言defer學習小結

go語言defer的使用

相關推薦