Golang中的defer

头像
好文收藏
     北京
    阅读 7 分钟

    面试常问之defer()的执行次序


    情形1


    package main

func main() {

    defer print(123)
    defer_call()
    defer print(789) //panic之后的代码不会被执行
    print("不会执行到这里")
}

func defer_call() {
    defer func() {
        print("打印前")
    }()
    defer func() {
        print("打印中")
    }()

    defer print("打印后")

    panic("触发异常")

    defer print(666)   //IDE会有提示: Unreachable code
    
}

    结果为:

    打印后打印中打印前123panic: 触发异常

goroutine 1 [running]:
main.defer_call()
    /Users/shuangcui/explore/panicandrecover.go:19 +0xe5
main.main()
    /Users/shuangcui/explore/panicandrecover.go:6 +0x51

    可见:

    • panic之后的defer()不会被执行
    • panic之前的defer(),按照先进后出的次序执行,最后输出panic信息

    (defer机制底层,是用链表实现的一个栈)

    再如:

    func main() {

    fmt.Println(123)

    defer fmt.Println(999)

    subfunc()

}

func subfunc() {

    defer fmt.Println(888)

    for i := 0; i > 10; i++ {
        fmt.Println("当前i为:", i)
        panic("have a bug")
    }

    defer fmt.Println(456)

}

    结果为:

    123
456
888
999


    defer会延迟到当前函数执行 return 命令前被执行, 多个defer之间按LIFO先进后出顺序执行



    情形2 (在defer内打印defer之外的主方法里操作的变量)


    package main

import "fmt"

func main() {
    foo()
}

func foo() {
    i := 0
    defer func() {
        //i--
        fmt.Println("第一个defer", i)
    }()

    i++
    fmt.Println("+1后的i：", i)

    defer func() {
        //i--
        fmt.Println("第二个defer", i)
    }()

    i++
    fmt.Println("再+1后的i：", i)

    defer func() {
        //i--
        fmt.Println("第三个defer", i)
    }()

    i++
    fmt.Println("再再+1后的i：", i)

    i = i + 666

    fmt.Println("+666后的i为:", i)

}

    输出为:

    +1后的i： 1
再+1后的i： 2
再再+1后的i： 3
+666后的i为: 669
第三个defer 669
第二个defer 669
第一个defer 669


    情形3 (在defer内外操作同一变量)


    package main

import "fmt"

func main() {
    foo()
}

func foo() {
    i := 0
    defer func() {
        i--
        fmt.Println("第一个defer", i)
    }()

    i++
    fmt.Println("+1后的i：", i)

    defer func() {
        i--
        fmt.Println("第二个defer", i)
    }()

    i++
    fmt.Println("再+1后的i：", i)

    defer func() {
        i--
        fmt.Println("第三个defer", i)
    }()

    i++
    fmt.Println("再再+1后的i：", i)

    i = i + 666

    fmt.Println("+666后的i为:", i)

}

    输出为:

    +1后的i： 1
再+1后的i： 2
再再+1后的i： 3
+666后的i为: 669
第三个defer 668
第二个defer 667
第一个defer 666


    情形4! (发生了参数传递!---传递参数给defer后面的函数, defer内外同时操作该参数)


    package main

import "fmt"

func main() {
    foo2()
}

func foo2() {
    i := 0
    defer func(k int) {
        //k--
        fmt.Println("第一个defer", k)
    }(i)

    i++
    fmt.Println("+1后的i：", i)

    defer func(k int) {
        //k--
        fmt.Println("第二个defer", k)
    }(i)

    i++
    fmt.Println("再+1后的i：", i)

    defer func(k int) {
        //k--
        fmt.Println("第三个defer", k)
    }(i)

    i++
    fmt.Println("再再+1后的i：", i)

    i = i + 666

    fmt.Println("+666后的i为:", i)

}

    输出为:

    +1后的i： 1
再+1后的i： 2
再再+1后的i： 3
+666后的i为: 669
第三个defer 2
第二个defer 1
第一个defer 0


    如果取消三处k--的注释, 输出为:

    +1后的i： 1
再+1后的i： 2
再再+1后的i： 3
+666后的i为: 669
第三个defer 1
第二个defer 0
第一个defer -1


    等同于:

    package main

import "fmt"

func main() {
    foo3()
}

func foo3() {
    i := 0
    defer f1(i)

    i++
    fmt.Println("+1后的i：", i)


    defer f2(i)

    i++
    fmt.Println("再+1后的i：", i)

    defer f3(i)
    i++
    fmt.Println("再再+1后的i：", i)

    i = i + 666

    fmt.Println("+666后的i为:", i)

}

func f1(k int) {
    k--
    fmt.Println("第一个defer", k)
}

func f2(k int) {
    k--
    fmt.Println("第二个defer", k)
}

func f3(k int) {
    k--
    fmt.Println("第三个defer", k)
}

    defer指定的函数的参数在 defer 时确定，更深层次的原因是Go语言都是值传递。


    情形5! (传递指针参数!---传递参数给defer后面的函数, defer内外同时操作该参数)


    package main

import "fmt"

func main() {

    foo5()
}

func foo5() {
    i := 0
    defer func(k *int) {
        fmt.Println("第一个defer", *k)
    }(&i)

    i++
    fmt.Println("+1后的i：", i)

    defer func(k *int) {
        fmt.Println("第二个defer", *k)
    }(&i)

    i++
    fmt.Println("再+1后的i：", i)

    defer func(k *int) {
        fmt.Println("第三个defer", *k)
    }(&i)

    i++
    fmt.Println("再再+1后的i：", i)

    i = i + 666

    fmt.Println("+666后的i为:", i)
}

    输出为:

    +1后的i： 1
再+1后的i： 2
再再+1后的i： 3
+666后的i为: 669
第三个defer 669
第二个defer 669
第一个defer 669


    作如下修改:

    package main

import "fmt"

func main() {

    foo5()
}

func foo5() {
    i := 0
    defer func(k *int) {
        (*k)--
        fmt.Println("第一个defer", *k)
    }(&i)

    i++
    fmt.Println("+1后的i：", i)

    defer func(k *int) {
        (*k)--
        fmt.Println("第二个defer", *k)
    }(&i)

    i++
    fmt.Println("再+1后的i：", i)

    defer func(k *int) {
        (*k)--
        fmt.Println("第三个defer", *k)
    }(&i)

    i++
    fmt.Println("再再+1后的i：", i)

    i = i + 666

    fmt.Println("+666后的i为:", i)
}

    输出为:

    +1后的i： 1
再+1后的i： 2
再再+1后的i： 3
+666后的i为: 669
第三个defer 668
第二个defer 667
第一个defer 666


    总结一下


    即

    • 如果传参进defer后面的函数(无论是闭包func(){}(i)方式还是子方法f(i)方式,或是直接跟如fmt.Println(i)),defer回溯时均以当时传参时i的值去计算
    • 反之,defer回溯时,以最后i的值带入计算;(参考下面的例子).

    参考:

    Go面试题答案与解析



    几种写法之间的归类与区别


    package main

import "fmt"

func main() {
    rs := foo6()
    fmt.Println("in main func:", rs)
}

func foo6() int {
    i := 0
    defer fmt.Println("in defer :", i)

    //defer func() {
    //    fmt.Println("in defer :", i)
    //}()

    i = 1000
    fmt.Println("in foo:", i)
    return i+24
}

    输出为:

    in foo: 1000
in defer : 0
in main func: 1024


    如果改为:

    package main

import "fmt"

func main() {
    rs := foo6()
    fmt.Println("in main func:", rs)
}

func foo6() int {
    i := 0
    //defer fmt.Println("in defer :", i)
    defer func() {
        fmt.Println("in defer :", i)
    }()

    i = 1000
    fmt.Println("in foo:", i)
    return i+24
}

    输出为:

    in foo: 1000
in defer : 1000
in main func: 1024


    也可见,

    defer fmt.Println("in defer :", i)

    相当于

    defer func(k int) {
        fmt.Println(k)
    }(i)

    或

    func f(k int){
    fmt.Println(k)
}

    这时的参数,都是传递时的值

    而如

        defer func() {
        fmt.Println("in defer :", i)
    }()

    这时的参数,为最后return之前那一刻的值



    defer会影响返回值吗?


    函数的return value 不是原子操作, 在编译器中实际会被分解为两部分：返回值赋值 和 return 。而defer刚好被插入到末尾的return前执行(即defer介于二者之间)。故可以在defer函数中修改返回值

    package main

import (
    "fmt"
)

func main() {
    fmt.Println(doubleScore(0))    //0
    fmt.Println(doubleScore(20.0)) //40
    fmt.Println(doubleScore(50.0)) //50
}
func doubleScore(source float32) (rs float32) {
    defer func() {
        if rs < 1 || rs >= 100 {
            //将影响返回值
            rs = source
        }
    }()
    rs = source * 2
    return
    //或者
    //return source * 2
}

    输出为:

    0
40
50

    再如:

    func main() {

    fmt.Println("foo return :", foo2())

}

func foo() map[string]string {

    m := map[string]string{}

    defer func() {
        m["a"] = "b"
    }()

    return m
}

    输出为:

    foo return : map[a:b]

    又如:

    package main


import "fmt"

func main() {
    fmt.Println("foo return :", foo())
}

func foo() int {
    i := 0

    defer func() {
        i = 10086
    }()

    return i + 5
}

    输出为:

    foo return : 5

    若作如下修改:

    
func foo() (i int) {
    i = 0
    defer func() {
        i = 10086
    }()

    return i + 5
}

    则返回为:

    foo return : 10086


    <font color="red">return之后的语句先执行，defer后的语句后执行</font>


    将return value拆解为两步: 确定value值,然后return..即如果return 后面是个方法或者复杂表达式,且有某个值i,会先计算.完成后defer再执行,如果defer里面也有对i的改动,是可以影响返回值的

    (给函数返回值申明变量名, 这时, 变量的内存空间空间是在函数执行前就开辟出来的，且该变量的作用域为整个函数,return时只是返回这个变量的内存空间的内容，因此defer能够改变返回值)

    defer不影响返回值，除非是map、slice和chan这三种引用类型，或者返回值定义了变量名



    参考:

    Golang研学：如何掌握并用好defer--存疑("引用传递"那里明显错误)

    Golang中的Defer必掌握的7知识点


    本文由mdnice多平台发布

    后端
    好文收藏
    38 声望6 粉丝

    好文收集

    « 上一篇
    Go context.WithCancel()的使用
    下一篇 »
    慎写指针类型的全局变量

    引用和评论

    推荐阅读
    头像
    是时候谈谈Go的测试了

    好文收藏阅读 22

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 5阅读 1.6k

    头像
    高质量代码的原则

    寒青赞 4阅读 5.3k

    头像
    日志与追踪的完美融合：OpenTelemetry MDC 实践指南

    crossoverJie赞 3阅读 1.6k

    头像
    Go 程序如何实现优雅退出？来看看 K8s 是怎么做的——上篇

    江湖十年赞 5阅读 673

    头像
    一文讲清楚static关键字

    seven97_top赞 4阅读 370

    头像
    每一个前端，都要拥有属于自己的埋点库~

    幸福的闹钟赞 2阅读 134

    0 条评论
    得票最新