Go语言的延迟调用是使用关键字defer来注册的，使得调用直到return前才被执行，多个defer语句按先进后出的方式执行，defer语句中的变量，在defer声明时就决定了。
defer常用于关闭文件句柄、锁资源释放、数据库连接释放。
例子：
package main
import "fmt"
func main() {
var whatever [5]struct{}
for i := range whatever {
defer fmt.Println(i)
}
}
2
3
4
5
6
7
8
9
10
11
代码输出：
4
3
2
1
0
2
3
4
5
从上面看出来，原本输出应该是0，1，2，3，4，但由于是先进后出，所以最后的小标4先输出了
defer功能强大，对于资源管理非常方便，但是如果没用好，也会有陷阱。因为是先进后出后面的语句会依赖前面的资源，因此如果先前面的资源先释放了，后面的语句就没法执行了。
# defer 碰上闭包
package main
import "fmt"
func main() {
var whatever [5]struct{}
for i := range whatever {
defer func() { fmt.Println(i) }()
}
}
2
3
4
5
6
7
8
9
10
代码输出：
4
4
4
4
4
2
3
4
5
其实Go说的很清楚,官方对 defer的解释:
Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usualand saved anew but the actual function is not invoked.
每次defer语句执行的时候，会把函数“压栈”，函数参数会被拷贝下来；当外层函数（非代码块，如一个for循环）退出时，defer函数按照定义的逆序执行；如果defer执行的函数为nil, 那么会在最终调用函数的产生panic.
也就是说函数正常执行,由于闭包用到的变量i 在执行的时候已经变成4,所以输出全都是4。
Go语言编程举了一个可能一不小心会犯错的例子:
package main
import "fmt"
type Test struct {
name string
}
func (t *Test) Close() {
fmt.Println(t.name, " closed")
}
func main() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
defer t.Close()
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
代码输出：
c closed
c closed
c closed
2
3
这个输出并不会像预计的输出c b a,而是输出c c c
可是按照前面的go spec中的说明,应该输出c b a才对啊.
那换一种方式来调用一下.
package main
import "fmt"
type Test struct {
name string
}
func (t *Test) Close() {
fmt.Println(t.name, " closed")
}
func Close(t Test) {
t.Close()
}
func main() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
defer Close(t)
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
代码输出：
c closed
b closed
a closed
2
3
这个时候输出的就是c b a
当然,如果不想多写一个函数,也很简单,可以像下面这样,同样会输出c b a
看似多此一举的声明
package main
import "fmt"
type Test struct {
name string
}
func (t *Test) Close() {
fmt.Println(t.name, " closed")
}
func main() {
ts := []Test{{"a"}, {"b"}, {"c"}}
for _, t := range ts {
t2 := t
defer t2.Close()
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
代码输出：
c closed
b closed
a closed
2
3
通过以上例子，结合
Each time a “defer” statement executes, the function value and parameters to the call are evaluated as usualand saved anew but the actual function is not invoked.
这句话。可以得出下面的结论：
defer后面的语句在执行的时候，函数调用的参数会被保存起来，但是不执行。也就是复制了一份。但是并没有说struct这里的this指针如何处理，通过这个例子可以看出Go语言并没有把这个明确写出来的this指针当作参数来看待。
多个 defer 注册，按先进后出次序执行。哪怕函数或某个延迟调用发生错误，这些调用依旧会被执行。
package main
func test(x int) {
defer println("a")
defer println("b")
defer func() {
println(100 / x) // div0 异常未被捕获，逐步往外传递，最终终止进程。
}()
defer println("c")
}
func main() {
test(0)
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
代码输出：
c
b
a
panic: runtime error: integer divide by zero
2
3
4
延迟调用参数在注册时求值或复制，可用指针或闭包 “延迟” 读取。
package main
func test() {
x, y := 10, 20
defer func(i int) {
println("defer:", i, y) // y 闭包引用
}(x) // x 被复制,此时是10
x += 10
y += 100
println("x =", x, "y =", y)
}
func main() {
test()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
代码输出:
x = 20 y = 120
defer: 10 120
2
滥用 defer 可能会导致性能问题，尤其是在一个 “大循环” 里。
package main
import (
"fmt"
"sync"
"time"
)
var lock sync.Mutex
func test() {
lock.Lock()
lock.Unlock()
}
func testdefer() {
lock.Lock()
defer lock.Unlock()
}
func main() {
func() {
t1 := time.Now()
for i := 0; i < 10000; i++ {
test()
}
elapsed := time.Since(t1)
fmt.Println("test elapsed: ", elapsed)
}()
func() {
t1 := time.Now()
for i := 0; i < 10000; i++ {
testdefer()
}
elapsed := time.Since(t1)
fmt.Println("testdefer elapsed: ", elapsed)
}()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
代码输出:
test elapsed: 82µs
testdefer elapsed: 503.7µs
2
# defer陷阱
# defer 与闭包( closure)
package main
import (
"errors"
"fmt"
)
func foo(a, b int) (i int, err error) {
defer fmt.Printf("first defer err %v\n", err)
defer func(err error) { fmt.Printf("second defer err %v\n", err) }(err)
defer func() { fmt.Printf("third defer err %v\n", err) }()
if b == 0 {
err = errors.New("divided by zero!")
return
}
i = a / b
return
}
func main() {
foo(2, 0)
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
代码输出：
third defer err divided by zero!
second defer err <nil>
first defer err <nil>
2
3
解释：如果 defer 后面跟的不是一个 闭包( closure)最后执行的时候我们得到的并不是最新的值。
# defer 与 return
package main
import "fmt"
func foo() (i int) {
i = 0
defer func() {
fmt.Println(i)
}()
return 2
}
func main() {
foo()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
代码输出：
2
解释：在有具名返回值的函数中（这里具名返回值为 i），执行 return 2 的时候实际上已经将 i的值重新赋值为 2。所以输出结果为 2 而不是 0。
# efer nil 函数
package main
import (
"fmt"
)
func test() {
var run func() = nil
defer run()
fmt.Println("runs")
}
func main() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
}()
test()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
代码输出：
runs
runtime error: invalid memory address or nil pointer dereference
2
解释：名为 test的函数一直运行至结束，然后 defer 函数会被执行且会因为值为 nil而产生 panic 异常。然而值得注意的是，run() 的声明是没有问题，因为在test函数运行完成后它才会被调用。
# 在错误的位置使用 defer
当 http.Get 失败时会抛出异常。
package main
import "net/http"
func do() error {
res, err := http.Get("http://www.google.com")
defer res.Body.Close()
if err != nil {
return err
}
// ..code...
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
代码输出：
panic: runtime error: invalid memory address or nil pointer dereference
因为在这里我们并没有检查我们的请求是否成功执行，当它失败的时候，我们访问了Body 中的空变量 res ，因此会抛出异常
# 解决方案
总是在一次成功的资源分配下面使用 defer，对于这种情况来说意味着：当且仅当 http.Get成功执行时才使用 defer
package main
import "net/http"
func do() error {
res, err := http.Get("http://xxxxxxxxxx")
if res != nil {
defer res.Body.Close()
}
if err != nil {
return err
}
// ..code...
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
在上述的代码中，当有错误的时候，err 会被返回，否则当整个函数返回的时候，会关闭 res.Body。
解释：在这里，你同样需要检查 res 的值是否为 nil ，这是 http.Get 中的一个警告。通常情况下，出错的时候，返回的内容应为空并且错误会被返回，可当你获得的是一个重定向 error时， res 的值并不会为 nil ，但其又会将错误返回。上面的代码保证了无论如何 Body 都会被关闭，如果你没有打算使用其中的数据，那么你还需要丢弃已经接收的数据。
# 不检查错误
在这里，f.Close() 可能会返回一个错误，可这个错误会被我们忽略掉
package main
import "os"
func do() error {
f, err := os.Open("book.txt")
if err != nil {
return err
}
if f != nil {
defer f.Close()
}
// ..code...
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
改进一下
package main
import "os"
func do() error {
f, err := os.Open("book.txt")
if err != nil {
return err
}
if f != nil {
defer func() {
if err := f.Close(); err != nil {
// log etc
}
}()
}
// ..code...
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
再改进一下
通过命名的返回变量来返回 defer内的错误。
package main
import "os"
func do() (err error) {
f, err := os.Open("book.txt")
if err != nil {
return err
}
if f != nil {
defer func() {
if ferr := f.Close(); ferr != nil {
err = ferr
}
}()
}
// ..code...
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
释放相同的资源
如果你尝试使用相同的变量释放不同的资源，那么这个操作可能无法正常执行。
package main
import (
"fmt"
"os"
)
func do() error {
f, err := os.Open("book.txt")
if err != nil {
return err
}
if f != nil {
defer func() {
if err := f.Close(); err != nil {
fmt.Printf("defer close book.txt err %v\n", err)
}
}()
}
// ..code...
f, err = os.Open("another-book.txt")
if err != nil {
return err
}
if f != nil {
defer func() {
if err := f.Close(); err != nil {
fmt.Printf("defer close another-book.txt err %v\n", err)
}
}()
}
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
代码输出：
defer close book.txt err close ./another-book.txt: file already closed
当延迟函数执行时，只有最后一个变量会被用到，因此，f 变量 会成为最后那个资源 (another-book.txt)。而且两个 defer 都会将这个资源作为最后的资源来关闭
解决方案：
package main
import (
"fmt"
"io"
"os"
)
func do() error {
f, err := os.Open("book.txt")
if err != nil {
return err
}
if f != nil {
defer func(f io.Closer) {
if err := f.Close(); err != nil {
fmt.Printf("defer close book.txt err %v\n", err)
}
}(f)
}
// ..code...
f, err = os.Open("another-book.txt")
if err != nil {
return err
}
if f != nil {
defer func(f io.Closer) {
if err := f.Close(); err != nil {
fmt.Printf("defer close another-book.txt err %v\n", err)
}
}(f)
}
return nil
}
func main() {
do()
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41