• 一些恐慌/恢复用例
    • 用例1：避免恐慌导致程序崩溃
    • 用例2：自动重启因为恐慌而退出的协程
    • 用例3：使用panic/recover函数调用模拟长程跳转
    • 用例4：使用panic/recover函数调用来减少错误检查代码

    一些恐慌/恢复用例

    恐慌和恢复（panic/recover）已经在之前的文章中介绍过了。下面将展示一些恐慌/恢复用例。

    用例1：避免恐慌导致程序崩溃

    这可能是最常见的panic/recover用例了。此用例广泛地使用于并发程序中，尤其是响应大量用户请求的应用。 一个例子：

    1. package main
    3. import "errors"
    4. import "log"
    5. import "net"
    7. func main() {
    8.     listener, err := net.Listen("tcp", ":12345")
    9.     if err != nil {
    10.         log.Fatalln(err)
    11.     }
    12.     for {
    13.         conn, err := listener.Accept()
    14.         if err != nil {
    15.             log.Println(err)
    16.         }
    17.         // 在一个新协程中处理客户端连接。
    18.         go ClientHandler(conn)
    19.     }
    20. }
    22. func ClientHandler(c net.Conn) {
    23.     defer func() {
    24.         if v := recover(); v != nil {
    25.             log.Println("捕获了一个恐慌：", v)
    26.             log.Println("防止了程序崩溃")
    27.         }
    28.         c.Close()
    29.     }()
    30.     panic("未知错误") // 演示目的产生的一个恐慌
    31. }

    运行此服务器程序，并在另一个终端窗口运行telnet localhost 12345，我们可以观察到服务器程序不会因为客户连接处理协程中的产生的恐慌而导致崩溃。

    如果我们在上例中不捕获客户连接处理协程中的潜在恐慌，则这样的恐慌将使整个程序崩溃。

    用例2：自动重启因为恐慌而退出的协程

    当在一个协程将要退出时，程序侦测到此协程是因为一个恐慌而导致此次退出时，我们可以立即重新创建一个相同功能的协程。一个例子：

    1. package main
    3. import "log"
    4. import "time"
    6. func shouldNotExit() {
    7.     for {
    8.         time.Sleep(time.Second) // 模拟一个工作负载
    9.         // 模拟一个未预料到的恐慌。
    10.         if time.Now().UnixNano() & 0x3 == 0 {
    11.             panic("unexpected situation")
    12.         }
    13.     }
    14. }
    16. func NeverExit(name string, f func()) {
    17.     defer func() {
    18.         if v := recover(); v != nil { // 侦测到一个恐慌
    19.             log.Printf("协程%s崩溃了，准备重启一个", name)
    20.             go NeverExit(name, f) // 重启一个同功能协程
    21.         }
    22.     }()
    23.     f()
    24. }
    26. func main() {
    27.     log.SetFlags(0)
    28.     go NeverExit("job#A", shouldNotExit)
    29.     go NeverExit("job#B", shouldNotExit)
    30.     select{} // 永久阻塞主线程
    31. }

    用例3：使用panic/recover函数调用模拟长程跳转

    有时，我们可以使用panic/recover函数调用来模拟跨函数跳转，尽管一般这种方式并不推荐使用。这种跳转方式的可读性不高，代码效率也不是很高，唯一的好处是它有时可以使代码看上去不是很啰嗦。 在下面这个例子中，一旦一个恐慌在一个内嵌函数中产生，当前协程中的执行将会跳转到延迟调用处。

    1. package main
    3. import "fmt"
    5. func main() {
    6.     n := func () (result int)  {
    7.         defer func() {
    8.             if v := recover(); v != nil {
    9.                 if n, ok := v.(int); ok {
    10.                     result = n
    11.                 }
    12.             }
    13.         }()
    15.         func () {
    16.             func () {
    17.                 func () {
    18.                     // ...
    19.                     panic(123) // 用恐慌来表示成功返回
    20.                 }()
    21.                 // ...
    22.             }()
    23.         }()
    24.         // ...
    25.         return 0
    26.     }()
    27.     fmt.Println(n) // 123
    28. }

    用例4：使用panic/recover函数调用来减少错误检查代码

    一个例子：

    1. func doSomething() (err error) {
    2.     defer func() {
    3.         err = recover()
    4.     }()
    6.     doStep1()
    7.     doStep2()
    8.     doStep3()
    9.     doStep4()
    10.     doStep5()
    12.     return
    13. }
    15. // 在现实中，各个doStepN函数的原型可能不同。
    16. // 每个doStepN函数的行为如下：
    17. // * 如果已经成功，则调用panic(nil)来制造一个恐慌
    18. //   以示不需继续；
    19. // * 如果本步失败，则调用panic(err)来制造一个恐慌
    20. //   以示不需继续；
    21. // * 不制造任何恐慌表示继续下一步。
    22. func doStepN() {
    23.     ...
    24.     if err != nil {
    25.         panic(err)
    26.     }
    27.     ...
    28.     if done {
    29.         panic(nil)
    30.     }
    31. }

    下面这段同功能的代码比上面这段代码看上去要啰嗦一些。

    1. func doSomething() (err error) {
    2.     shouldContinue, err := doStep1()
    3.     if !shouldContinue {
    4.         return err
    5.     }
    6.     shouldContinue, err = doStep2()
    7.     if !shouldContinue {
    8.         return err
    9.     }
    10.     shouldContinue, err = doStep3()
    11.     if !shouldContinue {
    12.         return err
    13.     }
    14.     shouldContinue, err = doStep4()
    15.     if !shouldContinue {
    16.         return err
    17.     }
    18.     shouldContinue, err = doStep5()
    19.     if !shouldContinue {
    20.         return err
    21.     }
    23.     return
    24. }
    26. // 如果返回值err不为nil，则shouldContinue一定为true。
    27. // 如果shouldContinue为true，返回值err可能为nil或者非nil。
    28. func doStepN() (shouldContinue bool, err error) {
    29.     ...
    30.     if err != nil {
    31.         return false, err
    32.     }
    33.     ...
    34.     if done {
    35.         return false, nil
    36.     }
    37.     return true, nil
    38. }

    但是，这种panic/recover函数调用的使用方式一般并不推荐使用，因为它的效率略低一些，并且这种用法不太符合Go编程习俗。

    Go语言101项目目前同时托管在Github和Gitlab上。欢迎各位在这两个项目中通过提交bug和PR的方式来改进完善Go语言101中的各篇文章。

    本书微信公众号名称为"Go 101"。每个工作日此公众号将尽量发表一篇和Go语言相关的原创短文。各位如果感兴趣，可以搜索关注一下。

    赞赏