go defer-recover-panic 学习

字数 2637阅读 39

本文将会讲解defer, recover,panic相关的知识。主要内容包括:

  • defer的原理
  • panic与recover的原理及注意事项

其中重点在defer的原理。这部分包含了defer的定义、规则、实现原理、内部函数顺序四部分。

希望看完本文,你能对defer、recover、panic有个全面的认识~

一、defer的原理

定义

1、defer语句用于延迟函数的调用,每次defer都会把一个函数压入栈中,主函数(创建defer的函数)返回前再把延迟的函数取出并执行。defer最常见的场景是完成一些收尾的工作,比如文件句柄的关闭等。还有就是执行 recover, 实现类似其他语言中的try catch finally。
2、延迟函数可能有输入参数,这些参数可能来源于定义defer的函数,延迟函数也可能引用主函数用于返回的变量,也就是说延迟函数可能会影响主函数的一些行为。

规则

规则一、其实使用defer时,用一个简单的转换规则改写一下,就不会迷糊了。改写规则是将return语句拆成两句写,return xxx会被改写成:
返回值 = xxx
调用defer的函数
空的return
规则一的几个案例

下面通过一些案例进行总结:

题目一
func deferFuncParameter() {    
    var aInt = 1
    defer fmt.Println(aInt)
    aInt = 2
    return
}

延迟函数fmt.Println(aInt) 在defer语句出现时就已经确定了,所以无论后面如何修改aInt的值都不会影响延迟函数。
上述程序转换之后是这样的:

func deferFuncParameter() {    
    var aInt = 1
    anonymous = aInt // anonymous为匿名的变量
    aInt = 2
    fmt.Println(anonymous)
    return
}

即使是结构体,也是传值,也不会影响。比如

type Test struct {
    value int
}

func (t Test) print() {
    println(t.value)
}

func main() {
    test := Test{}
    defer test.print()
    test.value += 1
}

这段代码输出的也是0.
如果是结构体指针,则会影响输出。

type Test struct {
    value int
}

func (t *Test) print() {
    println(t.value)
}

func main() {
    test := Test{}
    defer test.print()
    test.value += 1
}

这个输出的就是1, 因为传递的指针。

题目二
func printArray(array *[3]int) {    
   for i := range array {
       fmt.Println(array[i])
   }
}

func deferFuncParameter() {
   var aArray = [3]int{1, 2, 3}    
   defer printArray(&aArray)
   aArray[0] = 10
   return
}

func main() {
   deferFuncParameter()
}

函数deferFuncParameter定义了一个数组,通过defer调用printArray, 最后修改数组的第一个元素。printArray 函数接收数组的指针,即数组的地址,由于延迟函数执行时机在return语句之前,所以对数组的最终修改值被打印出来。

题目三
func deferFuncReturn() (result int) {    
    i := 1
    defer func() {
       result++
    }()    
    return i
}

函数的return语句并不是原子的,实际执行分为设置返回值->ret。defer语句实际执行在主函数返回(ret)前,即拥有defer的函数返回过程是 : 设置返回值->执行defer->ret。所以return语句先把result设置为i的值,即1,defer语句中又把result递增1,所以最终返回的是2.
上述程序可以转换为

func deferFuncReturn() (result int) {    
    i := 1
    result = i
    func() {
       result++
    }()    
    return 
}

总结上文的例子可以得出如下几个结论:

  • 延迟函数的参数在defer语句出现时就已经确定下来了
    如果是字面量,则肯定不受影响(如题目一); 如果是指针类型,规则仍然适用,只不过延迟函数的参数是一个地址值,这种情况下defer后面的语句对变量的修改可能会影响延迟函数(如题目二)。
  • 延迟函数可能操作主函数的具名返回值
    关键字return不是一个原子操作,实际上return只代理汇编指令ret,即将跳转程序执行。比如语句return i,实际上分两步进行,即将i值存入栈中作为返回值,然后执行跳转,而defer的执行时机正是跳转前,所以说defer执行时还是有机会操作返回值的。
规则二、从主函数返回值的角度看,有如下的几条规则:
1、主函数拥有匿名返回值,返回字面值
func foo() int {    
    var i int
    defer func() {
        i++
    }()    
    return 1
}

一个主函数拥有一个匿名的返回值,返回时使用字面值,比如”1“, ”hello“这样的值,这种情况下defer是无法操作返回值的。

2、主函数拥有匿名返回值,返回变量

一个主函数拥有一个匿名的返回值,返回使用本地或全局变量,这种情况下defer语句可以引用到返回值,但不会改变返回值。

func foo() int {    
    var i int
    defer func() {
        i++
    }()    
    return i
}

上面的函数,返回一个局部变量,同时defer函数也会操作这个局部变量。对于匿名返回值来说,可以假定仍然有一个变量存储返回值,假定返回值变量为"anony",上面的返回语句可以拆分成以下过程:

anony = i
i++
return

由于i是整型,会将值拷贝给anony,所以defer语句修改i值,对函数返回值不会造成影响。

3、主函数拥有具名返回值

主函数声明语句中带有名字的返回值,会被初始化一个局部变量,函数内部可以像使用局部变量一样使用该返回值。如果defer语句操作该返回值,可能会改变返回结果。

func foo() (ret int) {    
    defer func() {
        ret++
    }()    
    return 0}

上面的函数拆解之后是这样的:

ret = 0
ret++
return

defer实现原理

数据结构

每个goroutine数据结构中实际上也有一个defer指针,该指针指向一个defer的单链表,每次声明一个defer时就将defer插入到单链表表头,每次执行defer时就从单链表表头取出一个defer执行。


image.png
defer的创建和执行

源码包src/runtime/panic.go定义了两个方法分别用于创建defer和执行defer。

  • deferproc(): 在声明defer处调用,其将defer函数存入goroutine的链表中;
  • deferreturn():在return指令,准确的讲是在ret指令前调用,其将defer从goroutine链表中取出并执行。

可以简单这么理解,在编译在阶段,声明defer处插入了函数deferproc(),在函数return前插入了函数deferreturn()。

defer内部函数顺序

func TestDefer(t *testing.T) {
    fmt.Println("a")
    defer fmt.Println("b")
    defer c()
    defer d()
    fmt.Println("f")
}

func c() {
    fmt.Println("c")
}

func d() func(){
    fmt.Println("d")
    return func() {
        fmt.Println("e")
    }
}

输出为 a f d c b
结论:defer函数在函数执行结束后执行,若有多个defer函数,则执行顺序为后进先出。 主函数中,defer d() 并没有执行d()返回的闭包,所以结果里面并没有返回e.

func TestDefer(t *testing.T) {
    fmt.Println("a")
    defer fmt.Println("b")
    defer c()
    defer d()()
    fmt.Println("f")
}

func c() {
    fmt.Println("c")
}

func d() func(){
    fmt.Println("d")
    return func() {
        fmt.Println("e")
    }
}

这段代码只是在调用d方法时加了个括号,那么d方法返回的方法就会立即执行
返回结果为 a d f e c b 。 为什么不是 a f d e c b 呢? 这是因为在defer d()() 编译时,首先定义了函数d(), 此时就输出了d. 然后返回包含e的闭包函数。
即被defer标记的d函数中的程序“立即执行”,而d函数返回的函数则在测试方法结束后 按照“后进先出”的顺序执行。

再看一个 来自effective go的例子:

func trace(s string) string {
    fmt.Println("entering:", s)
    return s
}

func un(s string) {
    fmt.Println("leaving:", s)
}

func a() {
    defer un(trace("a"))
    fmt.Println("in a")
}

func b() {
    defer un(trace("b"))
    fmt.Println("in b")
    a()
}

func main() {
    b()
}

结果会打印

entering: b
in b
entering: a
in a
leaving: a
leaving: b

没执行以前我以为是如下的结果:

in b
in a
entring: a
leaving: a
entring: b
leaving: b

为什么不对呢?
因为在编译时,b() 中的 defer un(trace("b")) ,是对un()函数的延迟,但是此时会执行trace("b")。
这个例子说明,defer标记的函数只是最外层的函数,如果defer标记函数的参数也是个函数,则作为参数的函数在编译时就会被执行了,不必等到defer标记函数执行时才执行。

二、panic与recover的原理及注意事项

  • panic内置函数停止当前goroutine的正常执行,当函数F调用panic时,函数F的正常执行被立即停止,然后运行所有在F函数中的defer函数,然后F返回到调用他的函数对于调用者G,F函数的行为就像panic一样,终止G的执行并运行G中所defer函数,此过程会一直继续执行到goroutine所有的函数。panic可以通过内置的recover来捕获。
  • recover内置函数用来管理含有panic行为的goroutine,recover运行在defer函数中,获取panic抛出的错误值,并将程序恢复成正常执行的状态。如果在defer函数之外调用recover,那么recover不会停止并且捕获panic错误如果goroutine中没有panic或者捕获的panic的值为nil,recover的返回值也是nil。由此可见,recover的返回值表示当前goroutine是否有panic行为

几个注意的问题

1、defer 表达式的函数如果定义在 panic 后面,该函数在 panic 后就无法被执行到
func main() {
    panic("a")
    defer func() {
        fmt.Println("b")
    }()
}

结果 b没有打印出来
而在defer后panic

func main() {
    defer func() {
        fmt.Println("b")
    }()
    panic("a")
}

结果b被正常打印。

2、F中出现panic时,F函数会立刻终止,不会执行F函数内panic后面的内容,但不会立刻return,而是调用F的defer,如果F的defer中有recover捕获,则F在执行完defer后正常返回,调用函数F的函数G继续正常执行
func G() {
    defer func() {
        fmt.Println("c")
    }()
    F()
    fmt.Println("继续执行")
}

func F() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("b")
    }()
    panic("a")
}

结果

捕获异常: a
b
继续执行
c
3、如果F的defer中无recover捕获,则将panic抛到G中,G函数会立刻终止,不会执行G函数内后面的内容,但不会立刻return,而调用G的defer...以此类推
func G() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("c")
    }()
    F()
    fmt.Println("继续执行")
}

func F() {
    defer func() {
        fmt.Println("b")
    }()
    panic("a")
}

结果

b
捕获异常: a
c
4、如果一直没有recover,抛出的panic到当前goroutine最上层函数时,程序直接异常终止
func G() {
    defer func() {
        fmt.Println("c")
    }()
    F()
    fmt.Println("继续执行")
}

func F() {
    defer func() {
        fmt.Println("b")
    }()
    panic("a")
}

结果

b
c
panic: a

goroutine 1 [running]:
main.F()
    /xxxxx/src/xxx.go:61 +0x55
main.G()
    /xxxxx/src/xxx.go:53 +0x42
exit status 2
5、recover都是在当前的goroutine里进行捕获的,这就是说,对于创建goroutine的外层函数,如果goroutine内部发生panic并且内部没有用recover,外层函数是无法用recover来捕获的,这样会造成程序崩溃
func G() {
    defer func() {
        //goroutine外进行recover
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("c")
    }()
    //创建goroutine调用F函数
    go F()
    time.Sleep(time.Second)
}

func F() {
    defer func() {
        fmt.Println("b")
    }()
    //goroutine内部抛出panic
    panic("a")
}

结果:

b
panic: a

goroutine 5 [running]:
main.F()
    /xxxxx/src/xxx.go:67 +0x55
created by main.main
    /xxxxx/src/xxx.go:58 +0x51
exit status 2
6、recover返回的是interface{}类型而不是go中的 error 类型,如果外层函数需要调用err.Error(),会编译错误,也可能会在执行时panic
func main() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err.Error())
        }
    }()
    panic("a")
}

编译错误,结果

err.Error undefined (type interface {} is interface with no methods)
func main() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", fmt.Errorf("%v", err).Error())
        }
    }()
    panic("a")
}

结果:

捕获异常: a

参考文献

Go defer实现原理剖析
理解 Go 语言 defer 关键字的原理
defer关键字
golang中的defer函数的执行顺序
go defer,panic,recover详解 go 的异常处理
effective_go中文版
谈谈 panic 和 recover 的原理,讲的比较深入

推荐阅读更多精彩内容