go语言defer语句的用法

参考：https://www.jianshu.com/p/5b0b36f398a2

defer的语法

defer后面必须是函数调用语句，不能是其他语句，否则编译器会出错。

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

这个例子中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语句所在的函数执行结束的时候会被调用；我们查看一下汇编吗，看看defer是在什么时候被执行的：
定义两个函数foo1和foo2，功能和代码都是一样，只是其中一个包含defer语句，另一个没有。

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

这是foo1的汇编代码：

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

再看foo2的汇编代码：

func foo2(i int) int {44d690:   64 48 8b 0c 25 f8 ff    mov    %fs:0xfffffffffffffff8,%rcx44d697:   ff ff44d699:   48 3b 61 10             cmp    0x10(%rcx),%rsp44d69d:   76 70                   jbe    44d70f <main.foo2+0x7f>44d69f:   48 83 ec 18             sub    $0x18,%rsp44d6a3:   48 89 6c 24 10          mov    %rbp,0x10(%rsp)44d6a8:   48 8d 6c 24 10          lea    0x10(%rsp),%rbp44d6ad:   48 c7 44 24 28 00 00    movq   $0x0,0x28(%rsp)44d6b4:   00 00i = 10044d6b6:   48 c7 44 24 20 64 00    movq   $0x64,0x20(%rsp)44d6bd:   00 00defer 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,%eax44d6d9:   75 24                   jne    44d6ff <main.foo2+0x6f>44d6db:   eb 00                   jmp    44d6dd <main.foo2+0x4d>i = 20044d6dd:   48 c7 44 24 20 c8 00    movq   $0xc8,0x20(%rsp)44d6e4:   00 00return i44d6e6:   48 c7 44 24 28 c8 00    movq   $0xc8,0x28(%rsp)44d6ed:   00 0044d6ef:   90                      nop44d6f0:   e8 6b 48 fd ff          callq  421f60 <runtime.deferreturn>44d6f5:   48 8b 6c 24 10          mov    0x10(%rsp),%rbp44d6fa:   48 83 c4 18             add    $0x18,%rsp44d6fe:   c3                      retq...
}

通过比较很容易看出foo2有两处需要注意，第一处是defer foo()语句的翻译，这个翻译我没有细看懂，我猜是准备foo的函数参数(如果有)，然后保存这些参数值和foo的地址，注册到系统(runtime.deferproc)；另一处是return指令的翻译，return指令的执行分三步，第一步拷贝return值到返回值内存地址，第二步会调用runtime.deferreturn去执行前面注册的defer函数，第三部再执行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 codesreturn io.Copy(dst, src)
}

在打开输入文件输出文件后，不管后面的代码流程如何影响，这两个文件能够被自动关闭。

mutex对象锁住后的自动释放

func foo(...) {mu.Lock()defer mu.Unlock()// code logic
}

确保mu锁能够在函数foo退出之后自动释放。

注意0：如何让defer函数在宿主函数的执行中间执行

我们注意到defer函数的执行是在defer指令所在函数的运行结束之后，那么如何才能在所在函数的中间就释放呢，比如前面例子，在foo入口锁住了lock，而如果foo后半段的代码运行时间比较长，而此时又不需要继续保持住锁，该怎么办呢？

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 mainimport "log"
import "time"
import "sync"var mu sync.Mutexfunc 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的执行顺序

如果函数里面有多条defer指令，他们的执行顺序是反序，即后定义的defer先执行。

package mainimport "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 = 100foo(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 mainimport "log"func foo(n int) int {log.Println("n1=", n)defer log.Println("n=", n)n += 100log.Println("n2=", n)return n
}func main() {var i int = 100foo(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 mainimport "log"
import _ "time"func foo(n int) int {log.Println("n1=", n)defer func() {n += 100log.Println("n=", n)}()n += 100log.Println("n2=", n)return n
}func main() {var i int = 100foo(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

眼尖的同学会发现其中的问题；为什么n打印出来是300呢，不是明明说好defer函数的参数值在它出现时候计算，而不是在运行的时候计算的吗，n应该打印出200才对啊？
同学，仔细看一下原文：defer函数的参数在defer语句出现的位置计算，不是在defer函数运行的时刻计算；人家明明说的很清楚，defer函数的参数，请问这里n是参数吗，不是哎，这里引用的是宿主函数的局部变量，而不是参数；所以它拿到的是运行时刻的值。

这就引发出下一个注意事项。

注意4：defer函数会影响宿主函数的返回值

package mainimport "log"func foo1(i *int) int {*i += 100defer func() { *i += 200 }()log.Printf("i=%d", *i)return *i
}func foo2(i *int) (r int) {*i += 100defer func() { r += 200 }()log.Printf("i=%d", *i)return *i
}func main() {var i, r inti,r = 0,0r = foo1(&i)log.Printf("i=%d, r=%d\n", i, r)i,r = 0,0r = 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)

go语言的defer语句相关推荐

golang中defer语句使用小结
defer是Go语言中的延迟执行语句,用来添加函数结束时执行的代码,常用于释放某些已分配的资源.关闭数据库连接.断开socket连接.解锁一个加锁的资源.Go语言机制担保一定会执行defer语句中的代 ...
Go 语言之 defer 的前世今生
作者 | 欧长坤来源 | 码农桃花源延迟语句 defer 在最早期的 Go 语言设计中并不存在,后来才单独增加了这一特性,由 Robert Griesemer 完成语言规范的编写 [Griesem ...
Go函数--defer语句
1 defer语句该语句用于延迟调用指定的函数,它只能出现在函数或方法的内部,由defer 关键字以及针对某个函数的调用表达式组成.这里被调用的函数称为延迟函数.简单的示例如下 func outer ...
C语言循环选择还有,C语言第五讲,语句顺序循环选择.(示例代码)
C语言第五讲,语句顺序循环选择. 一丶语句的简明了解我们知道,在编写C语言程序的时候,代码是顺序执行的. 从上往下执行. 但是我们可以控制流程的. 在控制之前,我们要先熟悉什么是语句. 相比大家学 ...
Go 语言编程 — defer 关键字
目录文章目录目录 defer 关键字 defer 的用途之一:释放资源 defer 的用途之二:执行 recover(恢复) defer 特性多个 defer 的执行顺序被 deferred ...
go语言笔记——defer作用DB资源等free或实现调试
defer 和追踪关键字 defer 允许我们推迟到函数返回之前(或任意位置执行 return 语句之后)一刻才执行某个语句或函数(为什么要在返回之后才执行这些语句?因为 return 语句同样可以 ...
C语言第五讲,语句顺序循环选择.
C语言第五讲,语句顺序循环选择. 一丶语句的简明了解我们知道,在编写C语言程序的时候,代码是顺序执行的. 从上往下执行. 但是我们可以控制流程的. 在控制之前,我们要先熟悉什么是语句. 相比大家学 ...
【嵌入式】C语言高级编程-语句表达式(03)
00. 目录文章目录 00. 目录 01. C语言的表达式 02. C语言的语句 03. C语言中的代码块 04. C语言中的语句表达式 05. 宏中使用语句表达式 06. Linux内核应用示例 ...
c语言if else语句_查找C程序的输出（如果为else语句）| 设置1
c语言if else语句 Find the output of the following programs, 查找以下程序的输出, Program 1) 程序1) #include <stdi ...

go语言的defer语句