引子
package counter
import (
"log"
"sync"
)
type Counter struct {
mu *sync.Mutex
Value int
}
func NewCounter(value int) *Counter {
return &Counter{
new(sync.Mutex), 0,
}
}
func (c *Counter) Increment() {
c.mu.Lock()
// defer func
defer func() {
c.mu.Unlock()
log.Printf("mu sync.Mutex Unlocked!")
}()
// safe increment Value
c.Value++
}
概述
defer （延迟调用）是 Go语言中的一个关键字，一般用于释放资源和连接、关闭文件、释放锁等。
和defer类似的有java的finally和C++的析构函数，这些语句一般是一定会执行的（某些特殊情况后文会提到），不过析构函数析构的是对象，而defer后面一般跟函数或方法。
用法详解
1、 多个defer语句，按先进后出的方式执行
package main
import "fmt"
func main() {
var whatever [5]struct{}
for i := range whatever {
defer fmt.Println(i)
}
}
输出：
4
3
2
1
0
所有的defer语句会放入栈中，在入栈的时候会进行相关的值拷贝（也就是下面的“对应的参数会实时解析”）。
2、defer声明时，对应的参数会实时解析
简单示例：
package main
import "fmt"
func main() {
i := 1
fmt.Println("i =", i)
defer fmt.Print(i)
}
输出：
i = 1
1
defer后面的语句最后才会执行，后面会讲当defer存在时return的执行逻辑。
辨析：defer后面跟无参函数、有参函数和方法
package main
import "fmt"
//无返回值函数
func test(a int) {
defer fmt.Println("1、a =", a) // ④ 方法：值传递
defer func(v int) { fmt.Println("2、a =", v)} (a) // ③ 有参函数：值传递
defer func() { fmt.Println("3、a =", a)} () // ② 无参函数：函数调用，此时 a 已经是 2 了，故输出 2
a++ // ① defer 之前的最后一行代码行
}
func main() {
test(1)
}
输出：
3、a = 2
2、a = 1
1、a = 1
解释：
① a++变成2之后，3个defer语句以后声明先执行的顺序执行，
② 无参函数中使用的a现在已经是2了，故输出2。
③ 有参函数中的参数 v，会请求参数，直接把参数代入，所以输出1。
④ 方法中的参数a，直接把参数代入，所以输出1。
3、defer 读取函数返回值（return返回机制）
defer、return、返回值三者的执行逻辑是：
- return最先执行，return负责将结果写入返回值中；
- 接着defer开始执行一些收尾工作；
- 最后函数携带当前返回值（可能和最初的返回值不相同）退出。
当defer语句放在return后面时，不会被执行。
如下：
package main
import "fmt"
func f(i int) int{
return i
defer fmt.Print("i =", i) // 在 return i 语句之后，不会被执行
return i+1 // 不会被执行
}
func main() {
f(1)
}
没有输出，因为 return i 之后函数就已经结束了，不会执行 defer。
（1）无名返回值：
package main
import (
"fmt"
)
func a(i int) int {
defer func() {
i++
fmt.Println("defer2:", i)
}() // ③ 执行: i = 2
defer func() {
i++
fmt.Println("defer1:", i)
}() // ② 后声明,先执行: i = 1
return i // ① i = 0, 已经完成了返回值的赋值,但是这个时候先不返回; 先去执行 defer.
}
func main() {
var a = a(0)
fmt.Println("a:", a)
}
输出：
defer1: 1
defer2: 2
a: 0
解释说明：
①返回值由变量 i 赋值，相当于 返回值=i=0。
②第二个defer中 i++ , i= 1， 第一个 defer中i++, i = 2，所以最终i的值是2。
③但是返回值已经被赋值了，即使后续修改i也不会影响返回值。所以, 最终函数的返回值 = 0。
（2）有名返回值：
package main
import (
"fmt"
)
func b() (i int) { // 有名返回值: 此处函数声明, 已经指明了返回值就是 i
defer func() {
i++
fmt.Println("defer2:", i)
}()
defer func() {
i++
fmt.Println("defer1:", i)
}()
return i // 或者直接写成 return
}
func main() {
fmt.Println("return:", b())
}
输出：
defer1: 1
defer2: 2
return: 2
解释：
这里已经指明了返回值就是i，所以后续对i进行修改都相当于在修改返回值，所以最终函数的返回值是2。
（3）函数返回值为地址
package main
import (
"fmt"
)
func c() *int {
var i int
defer func() {
i++
fmt.Println("defer2:", i)
}()
defer func() {
i++
fmt.Println("defer1:", i)
}()
return &i
}
func main() {
fmt.Println("return:", *(c()))
}
输出：
defer1: 1
defer2: 2
return: 2
解释：
此时的返回值是一个指针（地址），这个指针 =&i，相当于指向变量i所在的地址，两个defer语句都对 i进行了修改，那么返回值指向的地址的内容也发生了改变，所以最终的返回值是2。
再看一个例子：
func f() (r int) {
defer func(r int) {
r = r + 5
}(r)
return r // 返回值 r
}
最初返回值r的值是1，虽然defer语句中函数的参数名也叫r，但传参的时候是值传递，返回值 r 并没有被修改，最终的返回值仍是1。
4、defer与闭包( ! 容易写出 bug)
package main
import "fmt"
type Test struct {
name string
}
func (t *Test) pp() {
fmt.Println(t.name)
}
func main() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
defer t.pp()
}
}
输出：
c
c
c
解释：
for 结束时 t.name=“c”，接下来执行的那些defer语句中用到的 t.name 的值均为”c“。
修改代码为：
package main
import "fmt"
type Test struct {
name string
}
func pp(t Test) {
fmt.Println(t.name)
}
func main() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
defer pp(t) // 这个故事告诉我们,尽量使用"局部变量"
}
}
输出：
c
b
a
解释：
defer语句中的参数会实时解析，所以在碰到defer语句的时候就把此时的 t 代入了。
再次修改代码：
package main
import "fmt"
type Test struct {
name string
}
func (t *Test) pp() {
fmt.Println(t.name)
}
func main() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
tt := t // 这个故事告诉我们,尽量使用"局部变量"
println(&tt)
defer tt.pp()
}
}
输出：
0xc000010200
0xc000010210
0xc000010220
c
b
a
解释：
① :=用来声明并赋值，连续使用2次a:=1就会报错，但是在for循环内，可以看出每次tt:=t时，tt 的地址都不同，说明他们是不同的变量，所以并不会报错。
② 每次都有一个新的变量tt:=t，所以每次在执行defer语句时，对应的tt不是同一个（for循环中实际上生成了3个不同的tt），所以输出的结果也不相同。
5、defer用于关闭文件和互斥锁
文件
func ReadFile(filename string) ([]byte, error) {
f, err := os.Open(filename)
if err != nil {
return nil, err
}
defer f.close() // finally close the file
return ReadAll()
}
互斥锁
var mu sync.Mutex
var m = make(map[string]int)
func lookup(key string) int {
mu.Lock()
defer mu.Unlock() // 延迟调用 Unlock(), finally
return m[key]
}
6、“解除”对所在函数的依赖
package main
import "fmt"
import "time"
type User struct {
username string
}
func (this *User) Close() {
fmt.Println(this.username, "Closed !!!")
}
func main() {
u1 := &User{"jack"}
defer u1.Close()
u2 := &User{"lily"}
defer u2.Close()
time.Sleep(10 * time.Second)
fmt.Println("Done !")
}
输出：
Done !
lily Closed !!!
jack Closed !!!
解释：
defer后面跟无参函数，u1.Close()和u2.Close()要等 sleep和 fmt.Println(“Done !”)之后才可以执行，也就是在函数最终返回之前执行。
修改代码为：
package main
import "fmt"
import "time"
type User struct {
username string
}
func (this *User) Close() {
fmt.Println(this.username, "Closed !!!")
}
func f(u *User) {
defer u.Close()
}
func main() {
u1 := &User{"jack"}
f(u1)
u2 := &User{"lily"}
func() { defer u2.Close() }()
time.Sleep(10 * time.Second)
fmt.Println("Done !")
}
输出：
jack Closed !!!
lily Closed !!!
Done !
这样的使用方式，似乎不太合理，但却有存在的必要性。大多数情况下，可以用于 u1,u2 之类非常消耗内存，或者cpu，其后执行时间过程且没有太多关联的情况。
既保留了defer的功能特性，也满足范围精确控制的条件 (???)
7、defer与panic
（1）在panic语句后面的defer语句不被执行
func panicDefer() {
panic("panic")
defer fmt.Println("defer after panic") // 不会执行到
}
输出：
panic: panic
goroutine 1 [running]:
main.panicDefer()
E:/godemo/testdefer.go:17 +0x39
main.main()
E:/godemo/testdefer.go:13 +0x20
Process finished with exit code 2
可以看到 defer 语句没有执行。
（2）在panic语句前的defer语句会被执行
func deferPanic() {
defer fmt.Println("defer before panic")
panic("panic")
}
输出：
defer before panic
panic: panic
goroutine 1 [running]:
main.deferPanic()
E:/godemo/testdefer.go:19 +0x95
main.main()
E:/godemo/testdefer.go:14 +0x20
Process finished with exit code 2
defer 语句输出了内容。
Go中的panic类似其它语言中的抛出异常，panic后面的代码不再执行(panic语句前面的defer语句会被执行)。
8、调用os.Exit时defer不会被执行
func deferExit() {
defer func() {
fmt.Println("defer")
}() // ① defer func
os.Exit(0) // 调用 os.Exit(), 不会执行 ① defer func
}
当调用os.Exit()方法退出程序时，defer并不会被执行，上面的defer并不会输出。
参考资料：
http://www.topgoer.com/函数/延迟调用defer.html
https://blog.csdn.net/eclipser1987/article/details/12089271
https://www.cnblogs.com/aiandbigdata/p/10822123.html
