這篇文章將為大家詳細講解有關Go中defer和panic以及recover的示例分析,文章內(nèi)容質(zhì)量較高,因此小編分享給大家做個參考,希望大家閱讀完這篇文章后對相關知識有一定的了解。
創(chuàng)新互聯(lián)建站是一家集網(wǎng)站建設,淮陽企業(yè)網(wǎng)站建設,淮陽品牌網(wǎng)站建設,網(wǎng)站定制,淮陽網(wǎng)站建設報價,網(wǎng)絡營銷,網(wǎng)絡優(yōu)化,淮陽網(wǎng)站推廣為一體的創(chuàng)新建站企業(yè),幫助傳統(tǒng)企業(yè)提升企業(yè)形象加強企業(yè)競爭力??沙浞譂M足這一群體相比中小企業(yè)更為豐富、高端、多元的互聯(lián)網(wǎng)需求。同時我們時刻保持專業(yè)、時尚、前沿,時刻以成就客戶成長自我,堅持不斷學習、思考、沉淀、凈化自己,讓我們?yōu)楦嗟钠髽I(yè)打造出實用型網(wǎng)站。
defer 語句將一個函數(shù)放入一個棧中,defer 會在當前函數(shù)返回前執(zhí)行傳入的函數(shù),經(jīng)常用于關閉文件描述符,數(shù)據(jù)庫連接,redis連接等,用于清理資源,避免資源浪費。比如下面這個栗子
package main import ( "fmt" "goapp/src/math") func main() { sum:=math.Add(2,3) fmt.Println(sum) defer func() {fmt.Println("i am defer1")}() res := test_defer(); fmt.Println(res) } func test_defer() float64 { defer func() {fmt.Println("i am defer2")}() defer func() {fmt.Println("i am defer3")}() res :=math3.Mod(5,3) return res; }
執(zhí)行結果是什么呢?
執(zhí)行 一個加法,打印返回值 5;
2.defer1入棧
3.執(zhí)行函數(shù)test_defer,defer2入棧,defer3入棧,執(zhí)行函數(shù)邏輯,在return 之前 呢,會執(zhí)行 棧里面的defer,棧嘛,先進后出,和隊列相反,所以依次執(zhí)行defer3,defer2,然后返回結果
4.main函數(shù)收到test_defer的返回值,開始打印結果
5.main函數(shù)在結束之前呢,會執(zhí)行一下本函數(shù)內(nèi)的defer,所以開始執(zhí)行defer1
那結果是不是這樣執(zhí)行的呢?我們來看一下結果,毫無相差
image.png
那么此處可能有小伙伴要問一下,defer為什么要設計成棧?
通俗來講一個場景,defer 是做清場工作的,對吧,那么這樣一個場景,一個小偷去倉庫偷東西,干完活了,要擦除腳印對吧,那他不可能從進門的位置開始擦腳印吧,他只能退著擦,先擦最后一步的腳印,而且,很多時候最后一步是基于前面的基礎上的,比如,還是這個小偷,他想偷柜子里面的珠寶,那他是不是得先打開門啊,那小偷做清理工作的時候,不可能先關閉門,在關閉柜子吧。
defer是用來釋放資源的,比如一個操作,先給文件上鎖,然后修改文件。那defer執(zhí)行的時候應該是先關閉文件,再釋放鎖。如果釋放鎖,再關閉文件,那不是亂套了嗎?從因果關系上說,后分配的資源可能會依賴前面的資源,但是前面的資源肯定不會依賴后面打開的資源。所以倒過來執(zhí)行關閉 不會產(chǎn)生問題。
那有的人說,我就是讓defer先進先出,不行嗎?允許是允許,但是不提倡。哈哈,是不是感受到了羅翔老師的氣場,請看下面的代碼,如果defer嵌套,那么defer會從外往里執(zhí)行,剝洋蔥似的,一層一層剝。
package main func main() { defer func() { println("i am defer1") defer func() { println("i am defer2") defer func() { println("i am defer3") }() }() }() panic("i am panic") }
panic往往和recover是成對出現(xiàn)的,與defer也有緊密的聯(lián)系,panic能夠改變程序的控制流,調(diào)用panic后會立刻停止執(zhí)行當前函數(shù)的剩余代碼,并在當前Goroutine(協(xié)程)中遞歸執(zhí)行調(diào)用方的defer
我們看下面一段代碼
package main import "time"func main() { defer func() { println("i am main defer1") }() go func() { defer func() { println("i am goroutine defer2") }() defer func() { println("i am goroutine defer3") }() panic("i am panic") defer func() { println("i am goroutine defer4") }() }() time.Sleep(1 * time.Second) }
從前面的分析我們得知以下結果
defer1 入棧
2.執(zhí)行goroutine 3.defer2 入棧 4.defer3入棧 5.panic打斷程序執(zhí)行,依次執(zhí)行defer3,defer2,panic,而panic 后面的程序不會再運行,并且main里面的defer也不會執(zhí)行
image.png
我為什么要加time.Sleep 如果不加呢?
從截圖里面看到,如果沒有time.Sleep,協(xié)程好像沒有被執(zhí)行一樣,為什么會這樣呢?因為我們知道,協(xié)程不是搶占式的,如果刪除time.Sleep,主goroutine不會放棄對輔助goroutine的控制,但是goroutine 必須放棄控制才能運行另一個goroutine,而time.Sleep就是放棄控制的一種方法。簡單來說,你這個程序 從頭到尾都是被main 主協(xié)程占用著,子協(xié)程不會主動搶占cpu,那么必須得是主協(xié)程主動讓出cpu,讓子協(xié)程有機會被cpu輪詢到,子協(xié)程才會被執(zhí)行
協(xié)程是go語言最重要的特色之一,那么我們怎么理解協(xié)程呢?協(xié)程,簡單說就是輕量級的線程,一個協(xié)程的大小是2k 左右,這也解釋了為什么go能單機百萬。
go語言里的協(xié)程創(chuàng)建很簡單,在go關鍵詞后面加一個函數(shù)調(diào)用就可以了。代碼舉栗
package main import "time"func main() { println("i am main goroutine") go func() { println("i am goroutine_in_1") go func() { println("i am goroutine_in_2") go func() { println("i am goroutine_in_3") }() }() }() time.Sleep(1*time.Second); println("main goroutine is over") }
image.png
main 函數(shù)是怎么運行的呢?其實main函數(shù)也是運行在goroutine里面,不過是主協(xié)程,上面的栗子我們是嵌套了幾個協(xié)程,但是他們中間并沒有什么層級關系,協(xié)程只有兩種,子協(xié)程和主協(xié)程。上面的代碼中,我們讓主協(xié)程休息了一秒,等待子協(xié)程返回結果。如果不讓主協(xié)程休息一秒,即讓出cpu,讓子協(xié)程是沒有機會執(zhí)行的,因為主協(xié)程運行結束后,不管子協(xié)程是任何狀態(tài),都會全部消亡。
但是在實際使用中,我們要保護好每一個子協(xié)程,確保他們安全運行,一個子協(xié)程的異常會傳播到主協(xié)程,直接導致主協(xié)程掛掉,程序崩潰。比如下面這個栗子
package main import "time"func main() { println("i am main goroutine") go func() { println("i am goroutine_in_1") go func() { println("i am goroutine_in_2") go func() { println("i am goroutine_in_3") panic("i am panic") }() }() }() time.Sleep(1*time.Second); println("main goroutine is over") }
最后一句,main goroutine is over沒有打印,程序沒有執(zhí)行到。 前面我們說到了。不管你是什么樣的程序,遇到panic 我就終止程序往下執(zhí)行,哪怕是子協(xié)程呢!好了,協(xié)程先說到這里。我們繼續(xù)往下看recover
recover 可以中止panic造成的程序崩潰,它是一個只能在defer中發(fā)揮作用的函數(shù)。在其他作用域中不會發(fā)揮作用。為什么這么說呢?我們看下面這個栗子
package main import "fmt"func main() { defer func() { println("i am main") }() if err := recover();err != nil { fmt.Println(err) } panic("i am panic") }
看一下執(zhí)行結果
image.png
我們看到,遇到panic,執(zhí)行了defer,然后執(zhí)行了panic ,并沒有執(zhí)行if條件判斷,為什么?recover是捕捉錯誤的,運行到if 還沒有錯誤,捕捉什么?運行到panic 的時候 if 已經(jīng)執(zhí)行過了,怎么捕捉?那么可能有人想,我把if放到panic后面不就行了嗎?行嗎?答案是否定的,panic 我們前面已經(jīng)說過了,甭管你是誰,看見我就得停止。那就回到我們剛才說的,panic 出現(xiàn),程序停止往下執(zhí)行,但是程序會循環(huán)執(zhí)行defer啊,那如果我在defer里面捕捉錯誤,是不是就可以解決這個問題了呢??梢奼o的設計者是用心良苦!到這里有沒有人會問一個問題defer可以嵌套,那么panic能否嵌套呢?當然可以,defer可以容納一切,panic放到defer里面一樣可以嵌套
package main func main() { defer func() { defer func() { defer func() { panic("i am panic3") }() panic("i am panic2") }() panic("i am panic1") }() panic("i am panic") }
為什么會先執(zhí)行 最后一行panic ,才執(zhí)行defer呢,這和前面說的遇到panic先執(zhí)行defer有點出入是吧,但是你這樣看 defer優(yōu)先于panic優(yōu)先于defer+panic。
那么現(xiàn)在,我們來寫一個例子,看defer 如何捕捉panic并恢復程序正常執(zhí)行
package main import "fmt"func main() { havePanic(); println("i will go on ") } func havePanic() { defer func() { if err:=recover();err !=nil { fmt.Println("i get a panic") fmt.Println(err) } }() panic("i am panic"); }
解讀一下上面的程序,執(zhí)行havePanic ,havePanic的第一個defer入棧,往下執(zhí)行碰到panic,首先會執(zhí)行defer,defer里面打印了err信息,并可以做一些其他的處理,比如記錄日志,重試什么的。然后main繼續(xù)執(zhí)行下面的print,看一下執(zhí)行結果
image.png
go不是號稱百萬協(xié)程嗎?那么我們真給它來個百萬協(xié)程看一下我的電腦到底能不能hold住
來!寫一段代碼
package main import ( "fmt" "time") func main() { i :=1; for { go func() { for { time.Sleep(time.Second) } }() if i > 1000000 { fmt.Printf("我已經(jīng)啟動了%d個協(xié)程\n",i) }else{ fmt.Printf("當前是第%d個協(xié)程\n",i) } i++ } }
截圖看一下我當前的機器狀態(tài)
百萬協(xié)程掛起之后的截圖
image.png
因為輸出跟不上速度其實最后跑了1842504個協(xié)程
說一下跑后感:風扇呼呼的轉(zhuǎn)了大概三分鐘的樣子 ,我算了一下一個協(xié)程大概是2.45kb的樣子
image.png
一個進程內(nèi)部可以運行多個線程,而每個線程又可以運行很多協(xié)程。線程要負責對協(xié)程進行調(diào)度,保證每個協(xié)程都有機會得到執(zhí)行。當一個協(xié)程睡眠時,它要將線程的運行權讓給其它的協(xié)程來運行,而不能持續(xù)霸占這個線程。同一個線程內(nèi)部最多只會有一個協(xié)程正在運行。
線程的調(diào)度是由操作系統(tǒng)負責的,調(diào)度算法運行在內(nèi)核態(tài),而協(xié)程的調(diào)用是由 Go 語言的運行時負責的,調(diào)度算法運行在用戶態(tài)。
協(xié)程可以簡化為三個狀態(tài),運行態(tài)、就緒態(tài)和休眠態(tài)。同一個線程中最多只會存在一個處于運行態(tài)的協(xié)程,就緒態(tài)的協(xié)程是指那些具備了運行能力但是還沒有得到運行機會的協(xié)程,它們隨時會被調(diào)度到運行態(tài),休眠態(tài)的協(xié)程還不具備運行能力,它們是在等待某些條件的發(fā)生,比如 IO 操作的完成、睡眠時間的結束等。
操作系統(tǒng)對線程的調(diào)度是搶占式的,也就是說單個線程的死循環(huán)不會影響其它線程的執(zhí)行,每個線程的連續(xù)運行受到時間片的限制。
Go 語言運行時對協(xié)程的調(diào)度并不是搶占式的。如果單個協(xié)程通過死循環(huán)霸占了線程的執(zhí)行權,那這個線程就沒有機會去運行其它協(xié)程了,你可以說這個線程假死了。不過一個進程內(nèi)部往往有多個線程,假死了一個線程沒事,全部假死了才會導致整個進程卡死。
每個線程都會包含多個就緒態(tài)的協(xié)程形成了一個就緒隊列,如果這個線程因為某個別協(xié)程死循環(huán)導致假死,那這個隊列上所有的就緒態(tài)協(xié)程是不是就沒有機會得到運行了呢?Go 語言運行時調(diào)度器采用了 work-stealing 算法,當某個線程空閑時,也就是該線程上所有的協(xié)程都在休眠(或者一個協(xié)程都沒有),它就會去其它線程的就緒隊列上去偷一些協(xié)程來運行。也就是說這些線程會主動找活干,在正常情況下,運行時會盡量平均分配工作任務。
默認情況下,Go 運行時會將線程數(shù)會被設置為機器 CPU 邏輯核心數(shù)。同時它內(nèi)置的 runtime 包提供了 GOMAXPROCS(n int) 函數(shù)允許我們動態(tài)調(diào)整線程數(shù),注意這個函數(shù)名字是全大寫。該函數(shù)會返回修改前的線程數(shù),如果參數(shù) n <=0 ,就不會產(chǎn)生修改效果,等價于讀操作。
package main import ( "fmt" "runtime") func main() { fmt.Print(runtime.GOMAXPROCS(0))//獲取默認線程數(shù) 8 println("\n") runtime.GOMAXPROCS(10)//設置線程數(shù)為10 fmt.Print(runtime.GOMAXPROCS(0))//獲取新線程數(shù) 10 }
關于Go中defer和panic以及recover的示例分析就分享到這里了,希望以上內(nèi)容可以對大家有一定的幫助,可以學到更多知識。如果覺得文章不錯,可以把它分享出去讓更多的人看到。