Go 延迟调用 defer 用法详解

引子

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、返回值三者的执行逻辑是:

  1. return最先执行,return负责将结果写入返回值中;
  2. 接着defer开始执行一些收尾工作;
  3. 最后函数携带当前返回值(可能和最初的返回值不相同)退出。

当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并不会输出。

本文链接:https://www.dzdvip.com/34359.html 版权声明:本文内容均来源于互联网。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 395045033@qq.com,一经查实,本站将立刻删除。
(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022年7月2日 22:55
下一篇 2022年7月2日 23:44

相关推荐

发表评论

您的电子邮箱地址不会被公开。