一些恐慌/恢复用例

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

一个例子：

package main

import "errors"
import "log"
import "net"

func main() {
    listener, err := net.Listen("tcp", ":12345")
    if err != nil {
        log.Fatalln(err)
    }
    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Println(err)
        }
        // 在一个新协程中处理客户端连接。
        go ClientHandler(conn)
    }
}

func ClientHandler(c net.Conn) {
    defer func() {
        if v := recover(); v != nil {
            log.Println("捕获了一个恐慌：", v)
            log.Println("防止了程序崩溃")
        }
        c.Close()
    }()
    panic("未知错误") // 演示目的产生的一个恐慌
}

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

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

package main

import “log”
import “time”
func shouldNotExit() {
    for {
        time.Sleep(time.Second) // 模拟一个工作负载
        // 模拟一个未预料到的恐慌。
        if time.Now().UnixNano() & 0x3 == 0 {
            panic(“unexpected situation”)
        }
    }
}
func NeverExit(name string, f func()) {
    defer func() {
        if v := recover(); v != nil { // 侦测到一个恐慌
            log.Printf(“协程%s崩溃了，准备重启一个”, name)
            go NeverExit(name, f) // 重启一个同功能协程
        }
    }()
    f()
}
func main() {
    log.SetFlags(0)
    go NeverExit(“job#A”, shouldNotExit)
    go NeverExit(“job#B”, shouldNotExit)
    select{} // 永久阻塞主线程
}

有时，我们可以使用panic/recover函数调用来模拟跨函数跳转，尽管一般这种方式并不推荐使用。 这种跳转方式的可读性不高，代码效率也不是很高，唯一的好处是它有时可以使代码看上去不是很啰嗦。

在下面这个例子中，一旦一个恐慌在一个内嵌函数中产生，当前协程中的执行将会跳转到延迟调用处。

package main

import "fmt"

func main() {
    n := func () (result int)  {
        defer func() {
            if v := recover(); v != nil {
                if n, ok := v.(int); ok {
                    result = n
                }
            }
        }()

        func () {
            func () {
                func () {
                    // ...
                    panic(123) // 用恐慌来表示成功返回
                }()
                // ...
            }()
        }()
        // ...
        return 0
    }()
    fmt.Println(n) // 123
}

一个例子：

func doSomething() (err error) {
    defer func() {
        err = recover()
    }()

    doStep1()
    doStep2()
    doStep3()
    doStep4()
    doStep5()

    return
}

// 在现实中，各个doStepN函数的原型可能不同。
// 每个doStepN函数的行为如下：
// * 如果已经成功，则调用panic(nil)来制造一个恐慌
//   以示不需继续；
// * 如果本步失败，则调用panic(err)来制造一个恐慌
//   以示不需继续；
// * 不制造任何恐慌表示继续下一步。
func doStepN() {
    ...
    if err != nil {
        panic(err)
    }
    ...
    if done {
        panic(nil)
    }
}

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

func doSomething() (err error) {
    shouldContinue, err := doStep1()
    if !shouldContinue {
        return err
    }
    shouldContinue, err = doStep2()
    if !shouldContinue {
        return err
    }
    shouldContinue, err = doStep3()
    if !shouldContinue {
        return err
    }
    shouldContinue, err = doStep4()
    if !shouldContinue {
        return err
    }
    shouldContinue, err = doStep5()
    if !shouldContinue {
        return err
    }

    return
}

// 如果返回值err不为nil，则shouldContinue一定为true。
// 如果shouldContinue为true，返回值err可能为nil或者非nil。
func doStepN() (shouldContinue bool, err error) {
    ...
    if err != nil {
        return false, err
    }
    ...
    if done {
        return false, nil
    }
    return true, nil
}

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