go/defer

defer使用

defer是Go语言提供的一种用于注册延迟调用的机制：让函数或语句可以在当前函数执行完毕后（包括通过return正常结束或者panic导致的异常结束）执行。

func main() {
    defer_call()
}

func defer_call() {
    defer func() { fmt.Println("打印前") }()
    defer func() { fmt.Println("打印中") }()
    defer func() { fmt.Println("打印后") }()
    panic("触发异常")
}

输出

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

goroutine 1 [running]:
main.defer_call()
        D:/GoProjs/interview/ts01/main.go:15 +0x98
main.main()
        D:/GoProjs/interview/ts01/main.go:8 +0x27
exit status 2

在Panic触发时结束函数运行，在return前先依次打印:打印后、打印中、打印前。最后由runtime运行时抛出打印panic异常信息。需要注意的是，函数的return value 不是原子操作，而是在编译器中分解为两部分：返回值赋值和return。而defer刚好被插入到末尾的return前执行。故可以在derfer函数中修改返回值。

defer拆解

return xxx

上面的return拆解如下

1. 返回值=xxx
2. 调用defer函数
3. 空的return

1，3步骤才是return语句真正的命令

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

底层原理

每次defer语句执行的时候，会把函数“压栈”，函数参数会被拷贝下来。defer语句并不会马上执行，而是会进入一个栈，函数return前，会按先进后出的顺序执行。也说是说最先被定义的defer语句最后执行。先进后出的原因是后面定义的函数可能会依赖前面的资源，自然要先执行；否则，如果前面先执行，那后面函数的依赖就没有了。如果defer执行的函数为nil, 那么会在最终调用函数的产生panic

在defer函数定义时，对外部变量的引用是有两种方式的，分别是作为函数参数和作为闭包引用。作为函数参数，则在defer定义时就把值传递给defer，并被cache起来；作为闭包引用的话，则会在defer函数真正调用时根据整个上下文确定当前的值。

defer后面的语句在执行的时候，函数调用的参数会被保存起来，也就是复制了一份。真正执行的时候，实际上用到的是这个复制的变量，因此如果此变量是一个“值”，那么就和定义的时候是一致的。如果此变量是一个“引用”，那么就可能和定义的时候不一致。

exp1

func main() {
    s := [3]int{1, 2, 3}
    for i := 0; i < 2; i++ {
        defer func() {
            fmt.Println(s[i])
        }()
    }
}

输出

3
3
// for循环完毕后才开始执行defer函数，而此时的i值为2

exp2

type number int

func (n number) print()   { fmt.Println(n) }
func (n *number) pprint() { fmt.Println(*n) }

func main() {
    var n number

    defer n.print()
    defer n.pprint()
    defer func() { n.print() }()
    defer func() { n.pprint() }()

    n = 3
}

输出

3
3
3
0
//第四个defer语句是闭包，引用外部函数的n, 最终结果是3; 
第三个defer语句同第四个；
第二个defer语句，n是引用，最终求值是3.
第一个defer语句，对n直接求值，开始的时候n=0, 所以最后是0;

exp3

func calc(index string, a, b int) int {
    ret := a + b
    fmt.Println(index, a, b, ret)
    return ret
}
func main() {
    a := 1                                            
    b := 2                                             
    defer calc("1", a, calc("10", a, b))  
    a = 0                                             
    defer calc("2", a, calc("20", a, b))  
    b = 1                                             
}

输出

10 1 2 3
20 0 2 2
2 0 2 2
1 1 3 4

注意

package main

import "fmt"

func main() {
    fmt.Println(getScore()) // 100
    fmt.Println(getScoreV2()) // 25.5
}

func getScore() float64 {
    var score float64
    defer func() {
        score = 25.5
    }()

    score = 100

    return score
}

func getScoreV2() (score float64) {
    defer func() {
        score = 25.5
    }()

    score = 100

    return score
}