首页 > 数据库 > defer、panic和recover
2020
02-16

defer、panic和recover

defer关键字

defer关键字可以让函数或语句延迟到函数语句块的最结尾时,即即将退出函数时执行,即便函数中途报错结束、即便已经panic()、即便函数已经return了,也都会执行defer所推迟的对象。

其实defer的本质是,当在某个函数中使用了defer关键字,则创建一个独立的defer栈帧,并将该defer语句压入栈中,同时将其使用的相关变量也拷贝到该栈帧中(显然是按值拷贝的)。因为栈是LIFO方式,所以先压栈的后执行。因为是独立的栈帧,所以即使调用者函数已经返回或报错,也一样能在它们之后进入defer栈帧去执行。

例如:

func main() {
    a()
} func a() { println("in a") defer b() // 将b()压入defer栈中 println("leaving a") //到了这里才会执行b() } func b() { println("in b") println("leaving b")
}

上面将输出:

in a
leaving a in b
leaving b

即便是函数已经报错,或函数已经return返回,defer的对象也会在函数退出前的最后一刻执行。

func a() TYPE{
    ...CODE... defer b()
    
    ...CODE... // 函数执行出了错误 return args // 函数b()都会在这里执行 }

但注意,由于Go的作用域采用的是词法作用域,defer的定义位置决定了它推迟对象能看见的变量值,而不是推迟对象被调用时所能看见的值。

例如:

package main var x = 10 func main() {
    a()
} func a() { println("start a:",x) // 输出10 x = 20 defer b(x) // 压栈,并按值拷贝20到栈中 x = 30 println("leaving a:",x) // 输出30 // 调用defer延迟的对象b(),输出20 } func b(x int) { println("start b:",x)
}

比较下面的defer:

package main var x = 10 func main() {
    a()
} func a() int { println("start a:", x) // 输出10 x = 20 defer func() { // 压栈,但并未传值,所以内部引用x println("in defer:", x) // 输出30 }()
    x = 30 println("leaving a:", x) // 输出30 return x
}

上面defer推迟的匿名函数输出的值是30,它看见的不应该是20吗?先再改成下面的:

package main var x = 10 func main() {
    a()
} func a() int { println("start a:", x) // 输出10 x = 20 defer func(x int) { println("in defer:", x) // 输出20 }(x)
    x = 30 println("leaving a:", x) // 输出30 return x
}

这个defer推迟的对象中看见的却是20,这和第一种defer b(x)是相同的。

原因在于defer推迟的如果是函数,它直接就在它的定义位置处评估好参数、变量。该拷贝传值的拷贝传值,该指针相见的指针相见。所以,对于第(1)和第(3)种情况,在defer的定义位置处,就将x=20拷贝给了推迟的函数参数,所以函数内部操作的一直是x的副本。而第二种情况则是直接指向它所看见的x=20那个变量,则个变量是全局变量,当执行x=30的时候会将其值修改,到执行defer推迟的对象时,它指向的x的值已经是修改过的。

再看下面这个例子,将defer放进一个语句块中,并在这个语句块中新声明一个同名变量x:

func a() int { println("start a:", x) // 输出10 x = 20 {
        x := 40 defer func() { println("in defer:", x) // 输出40 }()
    }
    x = 30 println("leaving a:", x) // 输出30 return x
}

上面的defer定义在语句块中,它能看见的x是语句块中x=40,它的x指向的是语句块中的x。另一方面,当语句块结束时,x=40的x会消失,但由于defer的函数中仍有x指向40这个值,所以40这个值仍被defer的函数引用着,它直到defer执行完之后才会被GC回收。所以defer的函数在执行的时候,仍然会输出40。

如果语句块内有多个defer,则defer的对象以LIFO(last in first out)的方式执行,也就是说,先定义的defer后执行。

func main() { println("start...") defer println("1") defer println("2") defer println("3") defer println("4") println("end...")
}

将输出:

start... end... 4 3 2 1

defer有什么用呢?一般用来做善后操作,例如清理垃圾、释放资源,无论是否报错都执行defer对象。另一方面,defer可以让这些善后操作的语句和开始语句放在一起,无论在可读性上还是安全性上都很有改善,毕竟写完开始语句就可以直接写defer语句,永远也不会忘记关闭、善后等操作。

例如,打开文件,关闭文件的操作写在一起:

open()
defer file.Close() ... 操作文件 ...

以下是defer的一些常用场景:

  • 打开关闭文件
  • 锁定、释放锁
  • 建立连接、释放连接
  • 作为结尾输出结尾信息
  • 清理垃圾(如临时文件)

panic()和recover()

panic()用于产生错误信息并终止当前的goroutine,一般将其看作是退出panic()所在函数以及退出调用panic()所在函数的函数。例如,G()中调用F(),F()中调用panic(),则F()退出,G()也退出。

注意,defer关键字推迟的对象是函数最后调用的,即使出现了panic也会调用defer推迟的对象。

例如,下面的代码中,main()中输出一个start main之后调用a(),它会输出start a,然后就panic了,panic()会输出panic: panic in a,然后报错,终止程序。

func main() { println("start main")
    a() println("end main")
} func a() { println("start a") panic("panic in a") println("end a")
}

执行结果如下:

start main
start a
panic: panic in a

goroutine 1 [running]:
main.a()
        E:/learning/err.go:14 +0x63
main.main()
        E:/learning/err.go:8 +0x4c exit status 2

注意上面的end a和end main都没有被输出。

可以使用recover()去捕获panic()并恢复执行。recover()用于捕捉panic()错误,并返回这个错误信息。但注意,即使recover()捕获到了panic(),但调用含有panic()函数的函数(即上面的G()函数)也会退出,所以如果recover()定义在G()中,则G()中调用F()函数之后的代码都不会执行(见下面的通用格式)。

以下是比较通用的panic()和recover()的格式:

func main() {
    G() // 下面的代码会执行 ...CODE IN MAIN...
} func G(){ defer func (){ if str := recover(); str != nil {
            fmt.Println(str)
        }
    }()
    ...CODE IN G()... // F()的调用必须在defer关键字之后 F() // 该函数内下面的代码不会执行 ...CODE IN G()...
} func F() {
    ...CODE1... panic("error found") // 下面的代码不会执行 ...CODE IN F()...
}

可以使用recover()去捕获panic()并恢复执行。但以下代码是错误的:

func main() { println("start main")
    a() println("end main")
} func a() { println("start a") panic("panic in a") // 直接放在panic后是错误的 panic_str := recover() println(panic_str) println("end a")
}

之所以错误,是因为panic()一出现就直接退出函数a()和main()了。要想recover()真正捕获panic(),需要将recover()放在defer的推迟对象中,且defer的定义必须在panic()发生之前。

例如,下面是通用格式的示例:

package main import "fmt" func main() { println("start main")
    b() println("end main")
} func a() { println("start a") panic("panic in a") println("end a")
} func b() { println("start b") defer func() { if str := recover(); str != nil {
            fmt.Println(str)
        }
    }()
    a() println("end b")
}

以下是输出结果:

start main start b start a
panic in a end main

注意上面的end b、end a都没有被输出,但是end main输出了。

panic()是内置的函数(在包builtin中),在log包中也有一个Panic()函数,它调用Print()输出信息后,再调用panic()。go doc log Panic一看便知:

$ go doc log Panic func Panic(v ...interface{}) Panic is equivalent to Print() followed by a call to panic().

扫码芷若 获取免费视频学习资料

编程学习

查 看2019高级编程视频教程免费获取