go語言defer語句的用法

defer的語法

defer后面必須是函數調用語句，不能是其他語句，否則編譯器會出錯。

package main

import "log"

func foo(n int) int {
    defer n++
    //defer log.Println("n=", n)
    return n
}

func main() {
    var i int = 100
    foo(i)
}

這個例子中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語句所在的函數執(zhí)行結束的時候會被調用；我們查看一下匯編嗎，看看defer是在什么時候被執(zhí)行的：
定義兩個函數foo1和foo2，功能和代碼都是一樣，只是其中一個包含defer語句，另一個沒有。

func foo1(i int) int {
    i = 100
    i = 200
    return i
}

func foo2(i int) int {
    i = 100
    defer foo()
    i = 200
    return i
}

這是foo1的匯編代碼：

func foo1(i int) int {
  44d660:   48 c7 44 24 10 00 00    movq   $0x0,0x10(%rsp)
  44d667:   00 00
    i = 100
  44d669:   48 c7 44 24 08 64 00    movq   $0x64,0x8(%rsp)
  44d670:   00 00
    i = 200
  44d672:   48 c7 44 24 08 c8 00    movq   $0xc8,0x8(%rsp)
  44d679:   00 00
    return i
  44d67b:   48 c7 44 24 10 c8 00    movq   $0xc8,0x10(%rsp)
  44d682:   00 00
  44d684:   c3                      retq
  ...
}

再看foo2的匯編代碼：

func foo2(i int) int {
  44d690:   64 48 8b 0c 25 f8 ff    mov    %fs:0xfffffffffffffff8,%rcx
  44d697:   ff ff
  44d699:   48 3b 61 10             cmp    0x10(%rcx),%rsp
  44d69d:   76 70                   jbe    44d70f <main.foo2+0x7f>
  44d69f:   48 83 ec 18             sub    $0x18,%rsp
  44d6a3:   48 89 6c 24 10          mov    %rbp,0x10(%rsp)
  44d6a8:   48 8d 6c 24 10          lea    0x10(%rsp),%rbp
  44d6ad:   48 c7 44 24 28 00 00    movq   $0x0,0x28(%rsp)
  44d6b4:   00 00
    i = 100
  44d6b6:   48 c7 44 24 20 64 00    movq   $0x64,0x20(%rsp)
  44d6bd:   00 00
    defer foo()
  44d6bf:   c7 04 24 00 00 00 00    movl   $0x0,(%rsp)
  44d6c6:   48 8d 05 93 fb 01 00    lea    0x1fb93(%rip),%rax        # 46d260 <go.func.*+0x41>
  44d6cd:   48 89 44 24 08          mov    %rax,0x8(%rsp)
  44d6d2:   e8 e9 3e fd ff          callq  4215c0 <runtime.deferproc>
  44d6d7:   85 c0                   test   %eax,%eax
  44d6d9:   75 24                   jne    44d6ff <main.foo2+0x6f>
  44d6db:   eb 00                   jmp    44d6dd <main.foo2+0x4d>
    i = 200
  44d6dd:   48 c7 44 24 20 c8 00    movq   $0xc8,0x20(%rsp)
  44d6e4:   00 00
    return i
  44d6e6:   48 c7 44 24 28 c8 00    movq   $0xc8,0x28(%rsp)
  44d6ed:   00 00
  44d6ef:   90                      nop
  44d6f0:   e8 6b 48 fd ff          callq  421f60 <runtime.deferreturn>
  44d6f5:   48 8b 6c 24 10          mov    0x10(%rsp),%rbp
  44d6fa:   48 83 c4 18             add    $0x18,%rsp
  44d6fe:   c3                      retq
  ...
}

通過比較很容易看出foo2有兩處需要注意，第一處是defer foo()語句的翻譯，這個翻譯我沒有細看懂，我猜是準備foo的函數參數(如果有)，然后保存這些參數值和foo的地址，注冊到系統(runtime.deferproc)；另一處是return指令的翻譯，return指令的執(zhí)行分三步，第一步拷貝return值到返回值內存地址，第二步會調用runtime.deferreturn去執(zhí)行前面注冊的defer函數，第三部再執(zhí)行ret匯編指令。

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

• file對象打開后的自動關閉

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    defer src.Close()

    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
    defer dst.Close()

    // other codes
    return io.Copy(dst, src)
}

在打開輸入文件輸出文件后，不管后面的代碼流程如何影響，這兩個文件能夠被自動關閉。

• mutex對象鎖住后的自動釋放

func foo(...) {
    mu.Lock()
    defer mu.Unlock()

    // code logic
}

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

注意0：如何讓defer函數在宿主函數的執(zhí)行中間執(zhí)行

我們注意到defer函數的執(zhí)行是在defer指令所在函數的運行結束之后，那么如何才能在所在函數的中間就釋放呢，比如前面例子，在foo入口鎖住了lock，而如果foo后半段的代碼運行時間比較長，而此時又不需要繼續(xù)保持住鎖，該怎么辦呢？

func foo() {
  mu.Lock();
  defer mu.Unlock();

  object, ok := map[key];
  if (!ok) {
      return
  }
  // time-consuming operating with object
  ...
}

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

package main

import "log"
import "time"
import "sync"

var mu sync.Mutex


func lock() {
    mu.Lock()
    log.Printf("lock")
}

func unlock() {
    mu.Unlock()
    log.Printf("unlock")
}

func foo() int {
    lock()

    func() {
        log.Printf("entry inner")
        defer unlock()
        log.Printf("exit inner")
    }()

    time.Sleep(1 * time.Second)
    log.Printf("return")
    return 0;
}

func main() {
    r := foo()
    log.Println("r=",r)
}

運行結果：

$ ./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函數結束的時候才釋放。

注意1：多個defer的執(zhí)行順序

如果函數里面有多條defer指令，他們的執(zhí)行順序是反序，即后定義的defer先執(zhí)行。

package main

import "log"
import "time"

func foo(n int) int {
    defer log.Println("1111")
    time.Sleep(1 * time.Second)
    defer log.Println("2222")
    time.Sleep(1 * time.Second)
    defer log.Println("3333")
    time.Sleep(1 * time.Second)
    return n
}

func main() {
    var i int = 100
    foo(i)
}

運行結果如下，可以看出他們的調用順序：

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

注意2：defer函數參數的計算時間點

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

package main

import "log"

func foo(n int) int {
    log.Println("n1=", n)
    defer log.Println("n=", n)
    n += 100
    log.Println("n2=", n)
    return n
}

func main() {
    var i int = 100
    foo(i)
}

其運行結果是：

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。

注意3：如何在defer語句里面使用多條語句

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

package main

import "log"
import _ "time"

func foo(n int) int {
    log.Println("n1=", n)
    defer func() {
        n += 100
        log.Println("n=", n)
    }()
    n += 100
    log.Println("n2=", n)
    return n
}

func main() {
    var i int = 100
    foo(i)
}

運行結果：

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

眼尖的同學會發(fā)現其中的問題；為什么n打印出來是300呢，不是明明說好defer函數的參數值在它出現時候計算，而不是在運行的時候計算的嗎，n應該打印出200才對??？
同學，仔細看一下原文：defer函數的參數在defer語句出現的位置計算，不是在defer函數運行的時刻計算；人家明明說的很清楚，defer函數的參數，請問這里n是參數嗎，不是哎，這里引用的是宿主函數的局部變量，而不是參數；所以它拿到的是運行時刻的值。

這就引發(fā)出下一個注意事項。

注意4：defer函數會影響宿主函數的返回值

package main

import "log"

func foo1(i *int) int {
    *i += 100
    defer func() { *i += 200 }()
    log.Printf("i=%d", *i)
    return *i
}

func foo2(i *int) (r int) {
    *i += 100
    defer func() { r += 200 }()
    log.Printf("i=%d", *i)
    return *i
}

func main() {
    var i, r int

    i,r = 0,0
    r = foo1(&i)
    log.Printf("i=%d, r=%d\n", i, r)

    i,r = 0,0
    r = foo2(&i)
    log.Printf("i=%d, r=%d\n", i, r)
}

運行結果為：

$ 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)