今天小编给大家分享一下Golang异常处理之defer,panic,recover如何使用的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。
延迟是什么
defer即延迟语句，极个别的情况下，Go才使⽤defer、panic、recover这种异常处理形式。
defer可以延迟函数、延迟⽅法、延迟参数。
延迟函数
可以在函数中添加多个defer语句。
当函数执⾏到最后时，这些defer语句会按照逆序执⾏，最后该函数返回。特别是当你在进⾏⼀些打开资源的操作时，遇到错误需要提前返回，在返回前你需要关闭
相应的资源，不然很容易造成资源泄露等问题
如果有很多调⽤defer，那么defer是采⽤后进先出模式
在离开所在的⽅法时，执⾏（报错的时候也会执⾏）
示例代码1：
package mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport "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 mainimport ( "fmt" "sync")type rect struct { length int width int}func (r rect) area(wg *sync.WaitGroup) { if r.length < 0 { fmt.Printf("rect %v's length should be greater than zero\n", r) wg.Done() return } if r.width < 0 { fmt.Printf("rect %v's width should be greater than zero\n", r) wg.Done() return } area := r.length * r.width fmt.Printf("rect %v's area %d\n", r, area) wg.Done()}func main() { var wg sync.WaitGroup r1 := rect{-67, 89} r2 := rect{5, -67} r3 := rect{8, 9} rects := []rect{r1, r2, r3} for _, v := range rects { wg.Add(1) go v.area(&wg) } wg.Wait() fmt.Println("All go routines finished executing")}修改以上代码：
package mainimport ( "fmt" "sync")type rect struct { length int width int}func (r rect) area(wg *sync.WaitGroup) { defer wg.Done() if r.length < 0 { fmt.Printf("rect %v's length should be greater than zero\n", r) return } if r.width < 0 { fmt.Printf("rect %v's width should be greater than zero\n", r) return } area := r.length * r.width fmt.Printf("rect %v's area %d\n", r, area) }func main() { var wg sync.WaitGroup r1 := rect{-67, 89} r2 := rect{5, -67} r3 := rect{8, 9} rects := []rect{r1, r2, r3} for _, v := range rects { wg.Add(1) go v.area(&wg) } wg.Wait() fmt.Println("All go routines finished executing")}程序运⾏结果：
rect {8 9}'s area 72
rect {-67 89}'s length should be greater than zero
rect {5 -67}'s width should be greater than zero
All go routines finished executing
panic和recover（宕机和宕机恢复）
panic和recover机制
概述：
panic：词义"恐慌"，recover：“恢复”
Go语⾔追求简洁优雅，Go没有像Java那样的 try…catch…finally 异常处理机制。Go语⾔设计者认为，将异常与流程控制混在⼀起会让代码变得混乱。
Go语⾔中，使⽤多值返回来返回错误。不⽤异常代替错误，更不⽤异常来控制流程。
go语⾔利⽤panic()，recover()，实现程序中的极特殊的异常处理。换句话说，极个别的情况下，Go才使⽤defer、panic、recover这种异常处理形式。
panic()，让当前的程序进⼊恐慌，中断程序的执⾏。或者说，panic是⼀个内建函数，可以中断原有的控制流程，进⼊⼀个令⼈恐慌的流程中。
当函数F调⽤panic，函数F的执⾏被中断，但是F中的延迟函数会正常执⾏，然后F返回到调⽤它的地⽅。在调⽤的地⽅，F的⾏为就像调⽤了panic。这⼀过程继续向上，直到发⽣panic的goroutine中所有调⽤的函数返回，此时程序退出。
恐慌可以直接调⽤panic产⽣。也可以由运⾏时错误产⽣，例如访问越界的数组。
recover 是⼀个内建的函数，可以让进⼊令⼈恐慌的流程中的goroutine恢复过来。
recover()，让程序恢复，必须在defer函数中执⾏。换句话说，recover仅在延迟函数中有效。
在正常 的执⾏过程中，调⽤recover会返回nil，并且没有其它任何效果。如果当前的goroutine陷⼊恐慌，调⽤ recover可以捕获到panic的输⼊值，并且恢复正常的执⾏。
⼀定要记住，应当把它作为最后的⼿段来使⽤，也就是说，我们的代码中应当没有，或者很少有panic这样的东⻄。
示例代码
package mainimport "fmt"func main() { 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 <= 10; i++ { fmt.Println("i:", i) if i == 5 { //让程序中断 panic("funB函数，恐慌啦。。。") //打断程序的执⾏。。 } } //当外围函数中的代码引发运⾏恐慌时，只有其中所有的延迟函数都执⾏完毕后，该运⾏时恐慌才会真正被扩展⾄调⽤函数。}func funC() { defer func() { fmt.Println("func的延迟函数。。。") //if msg := recover(); msg != nil { // fmt.Println(msg, "恢复啦。。。") //} fmt.Println("recover执⾏了" , recover()) }() fmt.Println("我是函数funC()。。") panic("funC恐慌啦。。") }以上就是“Golang异常处理之defer,panic,recover如何使用”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注编程网行业资讯频道。
