延迟是什么
defer即延迟语句,极个别的情况下,Go才使⽤defer、panic、recover这种异常处理形式。
defer可以延迟函数、延迟⽅法、延迟参数。
延迟函数
可以在函数中添加多个defer语句。
当函数执⾏到最后时,这些defer语句会按照逆序执⾏,最后该函数返回。特别是当你在进⾏⼀些打开资源的操作时,遇到错误需要提前返回,在返回前你需要关闭
相应的资源,不然很容易造成资源泄露等问题
如果有很多调⽤defer,那么defer是采⽤后进先出模式
在离开所在的⽅法时,执⾏(报错的时候也会执⾏)
示例代码1:
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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
结束!
延迟⽅法
延迟并不仅仅局限于函数。延迟⼀个⽅法调⽤也是完全合法的。
示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
|
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
延迟参数
延迟函数的参数在执⾏延迟语句时被执⾏,⽽不是在执⾏实际的函数调⽤时执⾏。
示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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实现字符串倒序
1
2
3
4
5
6
7
8
9
10
11
12
|
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的程序示例来理解这个问题。我们将⾸先编写程序⽽不使⽤延迟,然后我们将修改它以使⽤延迟,并理解延迟是多么有⽤。
示例代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
package main import ( "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" ) } |
修改以上代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
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 < 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机制
1.概述:
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这样的东⻄。
示例代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
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 <= 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的使用详解的详细内容,更多关于Golang defer panic recover的资料请关注服务器之家其它相关文章!
原文链接:https://blog.csdn.net/ekcchina/article/details/125014828