[[426205]]

引言

在Go語言中，我們通常會用到panic和recover來拋出錯誤和捕獲錯誤，這一對操作在單協程環境下我們正常用就好了，并不會踩到什么坑。但是在多協程并發環境下，我們常常會碰到以下兩個問題。假設我們現在有2個協程，我們叫它們協程A和B好了：

• 如果協程A發生了panic，協程B是否會因為協程A的panic而掛掉?
• 如果協程A發生了panic，協程B是否能用recover捕獲到協程A的panic?

答案分別是：會、不能。

那么下面我們來一一驗證，并給出在具體的業務場景下的最佳實踐。

問題一

• 如果協程A發生了panic，協程B是否會因為協程A的panic而掛掉?

為了驗證這個問題，我們寫一段程序：

package main 
 
import ( 
    "fmt" 
    "time" 
) 
 
func main() { 
 
    // 協程A 
    go func() { 
        for { 
            fmt.Println("goroutine1_print") 
        } 
    }() 
 
    // 協程B 
    go func() { 
        time.Sleep(1 * time.Second) 
        panic("goroutine2_panic") 
    }() 
 
    time.Sleep(2 * time.Second) 
} 

首先主協程開啟兩個子協程A和B，A協程不停的循環打印goroutine1_print字符串;B協程在睡眠1s后，就會拋出panic(睡眠這一步為了確保在A跑起來開始打印了之后，B才會panic)，主協程睡眠2s，等待A、B子協程全部執行完畢，主協程退出。最終打印結果如下：

... 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
panic: goroutine2_panicgoroutine1_print 
 
 
goroutine1_print 
goroutine goroutine1_print 
19goroutine1_print 
goroutine1_print 
goroutine1_print 
goroutine1_print 
 [runninggoroutine1_print 
]: 
goroutine1_print 
goroutine1_print 
goroutine1_print 
main.main.func2() 
        /Users/jiangbaiyan/go/src/awesomeProject/main.go:18 +0x46 
created by main.main 
        /Users/jiangbaiyan/go/src/awesomeProject/main.go:16 +0x4d 

我們可以看到，在協程B發生panic之前，協程A一直在打印字符串;然后協程A和panic交替打印字符串，最后主協程與協程A、B全部退出。所以我們可以看到，一個協程panic之后，是會導致所有的協程全部掛掉的，程序會整體退出，到這里我們就驗證了第一個問題的答案。

至于panic和協程A交替打印的原因，可能是因為panic也需要打印字符串。因為打印也是需要時間的，當我們執行panic這一行代碼的時候，到panic真正觸發所有協程掛掉，是需要一定的時間的(盡管這個時間很短暫)，所以再這一小段時間內，我們會看到交替打印的現象。

問題二

• 如果協程A發生了panic，其他協程是否能用recover捕獲到協程A的panic?

還是類似上面那段代碼，我們還可以再精簡一下：

package main 
 
import ( 
   "fmt" 
   "time" 
) 
 
func main() { 
 
   defer func() { 
       if e := recover(); e != nil { 
           fmt.Println("recover_panic") 
       } 
   }() 
 
   go func() { 
       panic("goroutine2_panic") 
   }() 
 
   time.Sleep(2 * time.Second) 
} 

我們這次只開啟一個協程，并在主協程中加入了recover，希望它能夠捕獲到子協程中的panic，但是結果未能如愿：

panic: goroutine2_panic 
 
goroutine 6 [running]: 
main.main.func2() 
       /Users/jiangbaiyan/go/src/awesomeProject/main.go:17 +0x39 
created by main.main 
       /Users/jiangbaiyan/go/src/awesomeProject/main.go:16 +0x57 
 
Process finished with exit code 2 

我們看到，recover并沒有生效。所以，哪個協程發生了panic，我們就需要在哪個協程recover，我們改成這樣：

package main 
 
import ( 
   "fmt" 
   "time" 
) 
 
func main() { 
 
   go func() { 
       defer func() { 
           if e := recover(); e != nil { 
               fmt.Println("recover_panic") 
           } 
       }() 
       panic("goroutine2_panic") 
   }() 
 
   time.Sleep(2 * time.Second) 
} 

結果成功打印recover_panic字符串：

recover_panic 
 
Process finished with exit code 0 

所以我們的答案也得到了驗證：協程A發生panic，協程B無法recover到協程A的panic，只有協程自己內部的recover才能捕獲自己拋出的panic。

最佳實踐

我們先假設有這樣一個場景，我們要開發一個客戶端，這個客戶端需要調用2個服務，這2個服務沒有任何先后順序的依賴，所以我們可以開啟2個goroutine，通過并發調用這兩個服務來獲得性能提升。那么這個時候我們剛才所談到的問題一就成了問題。

通常來講，我們不希望其中一個服務調用失敗，另一個服務調用也跟著失敗，而是要繼續執行完其他幾個服務調用邏輯，這個時候我們該怎么辦呢?

聰明的你一定會想到，我在每個協程內部編寫一個recover語句，讓他接住每個協程自己可能會發生的panic，就能夠解決一個協程panic而導致所有協程掛掉的問題了。我們編寫如下代碼，這就是在業務開發中，結合問題二解決問題一的最佳實踐：

// 并發調用服務，每個handler都會傳入一個調用邏輯函數 
func GoroutineNotPanic(handlers ...func() error) (err error) { 
 
    var wg sync.WaitGroup 
    // 假設我們要調用handlers這么多個服務 
    for _, f := range handlers { 
 
        wg.Add(1) 
        // 每個函數啟動一個協程 
        go func(handler func() error) { 
 
            defer func() { 
                // 每個協程內部使用recover捕獲可能在調用邏輯中發生的panic 
                if e := recover(); e != nil { 
                    // 某個服務調用協程報錯，可以在這里打印一些錯誤日志 
                } 
                wg.Done() 
            }() 
 
            // 取第一個報錯的handler調用邏輯，并最終向外返回 
            e := handler() 
            if err == nil && e != nil { 
                err = e 
            } 
        }(f) 
    } 
 
    wg.Wait() 
 
    return 
} 

以上方法調用示例：

// 調用示例 
func main() { 
 
    // 調用邏輯1 
    aRpc := func() error { 
        panic("rpc logic A panic") 
        return nil 
    } 
     
    // 調用邏輯2 
    bRpc := func() error { 
        fmt.Println("rpc logic B") 
        return nil 
    } 
 
    err := GoroutineNotPanic(aRpc, bRpc) 
    if err != nil { 
        fmt.Println(err) 
    } 
} 

這樣我們就實現了一個通用的并發處理邏輯，每次調用我們只需要把業務邏輯的函數傳入即可，不用每次自己單獨編寫一套并發控制邏輯;同時調用邏輯2就不會因為調用邏輯1的panic而掛掉了，容錯率更高。在業務開發中我們可以參考這種實現方式~

本文轉載自微信公眾號「NoSay」，可以通過以下二維碼關注。轉載本文請聯系NoSay公眾號。