Golang异常处理之defer,panic,recover的使用详解

本篇文章给大家分享《Golang异常处理之defer,panic,recover的使用详解》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

延迟是什么

defer即延迟语句，极个别的情况下，Go才使⽤defer、panic、recover这种异常处理形式。

defer可以延迟函数、延迟⽅法、延迟参数。

延迟函数

可以在函数中添加多个defer语句。

当函数执⾏到最后时，这些defer语句会按照逆序执⾏，最后该函数返回。特别是当你在进⾏⼀些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭

相应的资源，不然很容易造成资源泄露等问题

如果有很多调⽤defer，那么defer是采⽤后进先出模式

在离开所在的⽅法时，执⾏（报错的时候也会执⾏）

示例代码1：

package main
import "fmt"
func main() {
 defer funA()
 funB()
 funC()
 fmt.Println("main...over....") }
func funA() {
 fmt.Println("我是funA()...") }
func funB() { //
 fmt.Println("我是funB()...") }
func funC() {
 fmt.Println("我是funC()。。") }

运⾏结果：

我是funB()...
我是funC()。。
main...over....
我是funA()...

示例代码2：

package main
import "fmt"
func main() {
 s1 := []int{78, 109, 2, 563, 300}
 largest(s1) }
func finished() {
 fmt.Println("结束！") }
func largest(s []int) {
 defer finished()
 fmt.Println("开始寻找最⼤数...")
 max := s[0]
 for _, v := range s {
 if v > max {
 max = v
 }
 }
 fmt.Printf("%v中的最⼤数为：%v \n", s , max) }

运⾏结果：

开始寻找最⼤数…
[78 109 2 563 300]中的最⼤数为：563
结束！

延迟⽅法

延迟并不仅仅局限于函数。延迟⼀个⽅法调⽤也是完全合法的。

示例代码：

package main
import "fmt"
type person struct {
 firstName string
 lastName string
}
func (p person) fullName() {
 fmt.Printf("%s %s", p.firstName, p.lastName) }
func main() {
 p := person{"Steven", "Wang"}
 defer p.fullName()
 fmt.Printf("Welcome ") }

运⾏结果：

Welcome Steven Wang

延迟参数

延迟函数的参数在执⾏延迟语句时被执⾏，⽽不是在执⾏实际的函数调⽤时执⾏。

示例代码：

package main
import "fmt"
func printAdd(a , b int) {
 fmt.Printf("延迟函数中：参数a , b分别为%d,%d ，两数之和为：%d\n",
a , b , a+b) }
func main() {
 a := 5
 b := 6
 //延迟函数的参数在执⾏延迟语句时被执⾏，⽽不是在执⾏实际的函数调
⽤时执⾏。
 defer printAdd(a , b)
 a = 10
 b = 7
 fmt.Printf("延迟函数执⾏前：参数a , b分别为%d,%d ，两数之和为：
%d\n", a , b , a+b) }

运⾏结果：

延迟函数执⾏前：参数a , b分别为10,7 ，两数之和为：17
延迟函数中：参数a , b分别为5,6 ，两数之和为：11

堆栈的推迟

当⼀个函数有多个延迟调⽤时，它们被添加到⼀个堆栈中，并在Last In First Out（LIFO）后进先出的顺序中执⾏。

示例代码：利⽤defer实现字符串倒序

package main
import "fmt"
func main() {
 name := "StevenWang欢迎学习区块链"
 fmt.Printf("原始字符串: %s\n", name)
 fmt.Println("翻转后字符串: ")
 ReverseString(name) }
func ReverseString(str string) {
 for _, v := range []rune(str) {
 defer fmt.Printf("%c", v)
 }
}

返回结果：

原始字符串: StevenWang欢迎学习区块链
翻转后字符串:
链块区习学迎欢gnaWnevetS

延迟的应⽤

到⽬前为⽌，我们所写的示例代码，并没有实际的应⽤。现在看⼀下关于延迟的应⽤。在不考虑代码流的情况下，延迟被执⾏。让我们以⼀个使⽤WaitGroup的程序示例来理解这个问题。我们将⾸先编写程序⽽不使⽤延迟，然后我们将修改它以使⽤延迟，并理解延迟是多么有⽤。

示例代码：

package main
import (
 "fmt"
 "sync"
)
type rect struct {
 length int
 width int
}
func (r rect) area(wg *sync.WaitGroup) {
 if r.length 
<p>修改以上代码：</p>
<pre class="brush:go;">package main
import (
 "fmt"
 "sync"
)
type rect struct {
 length int
 width int
}
func (r rect) area(wg *sync.WaitGroup) {
 defer wg.Done()
 if r.length 
<p>程序运⾏结果：</p>
<blockquote><p>rect {8 9}'s area 72<br>rect {-67 89}'s length should be greater than zero<br>rect {5 -67}'s width should be greater than zero<br>All go routines finished executing</p></blockquote>
<h2>panic和recover（宕机和宕机恢复）</h2>
<h3>panic和recover机制</h3>
<p>1.概述：</p>
<p>panic：词义"恐慌"，recover：“恢复”</p>
<p>Go语⾔追求简洁优雅，Go没有像Java那样的 try…catch…finally 异常处理机制。Go语⾔设计者认为，将异常与流程控制混在⼀起会让代码变得混乱。</p>
<p>Go语⾔中，使⽤多值返回来返回错误。不⽤异常代替错误，更不⽤异常来控制流程。</p>
<p>go语⾔利⽤panic()，recover()，实现程序中的极特殊的异常处理。换句话说，极个别的情况下，Go才使⽤defer、panic、recover这种异常处理形式。</p>

• panic()，让当前的程序进⼊恐慌，中断程序的执⾏。或者说，panic是⼀个内建函数，可以中断原有的控制流程，进⼊⼀个令⼈恐慌的流程中。
• 当函数F调⽤panic，函数F的执⾏被中断，但是F中的延迟函数会正常执⾏，然后F返回到调⽤它的地⽅。在调⽤的地⽅，F的⾏为就像调⽤了panic。这⼀过程继续向上，直到发⽣panic的goroutine中所有调⽤的函数返回，此时程序退出。
• 恐慌可以直接调⽤panic产⽣。也可以由运⾏时错误产⽣，例如访问越界的数组。
• recover 是⼀个内建的函数，可以让进⼊令⼈恐慌的流程中的goroutine恢复过来。
• recover()，让程序恢复，必须在defer函数中执⾏。换句话说，recover仅在延迟函数中有效。
• 在正常 的执⾏过程中，调⽤recover会返回nil，并且没有其它任何效果。如果当前的goroutine陷⼊恐慌，调⽤ recover可以捕获到panic的输⼊值，并且恢复正常的执⾏。

⼀定要记住，应当把它作为最后的⼿段来使⽤，也就是说，我们的代码中应当没有，或者很少有panic这样的东⻄。

示例代码

package main
import "fmt"
func main() {
 /*
 panic：词义"恐慌"，
 recover："恢复"
 go语⾔利⽤panic()，recover()，实现程序中的极特殊的异常的处理
 panic(),让当前的程序进⼊恐慌，中断程序的执⾏
 recover(),让程序恢复，必须在defer函数中执⾏
 */
 funA()
 funB()
 funC()
 fmt.Println("main...over....") }
func funA() {
 fmt.Println("我是函数funA()...") }
func funB() { //外围函数
 defer func() {
 if msg := recover(); msg != nil {
 fmt.Println(msg, "恢复啦。。。")
 }
 }()
 fmt.Println("我是函数funB()...")
 for i := 1; i 
<p>以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。</p>