panic 和 recover 机制

在 Go 语言中，panic 是一种异常处理机制，用于表示程序发生了不可恢复的错误。当函数调用发生严重错误时，可以调用 panic 函数来引发 panic，导致程序立即停止执行。

当 panic 被调用时，程序的正常执行流程会被中断，立即执行该函数的延迟调用（defer语句）。然后程序会开始沿着调用栈往上寻找对应的 recover 函数。

• 如果找到了对应的 recover 函数，程序会恢复正常执行，继续执行之后的代码；
• 如果没有找到对应的 recover 函数，程序会终止，并在终止前执行程序中已注册的延迟调用。

recover 函数用于从 panic 中恢复。当 recover 函数被调用时，它会停止 panic 的传播，返回传递给 panic 的参数值，并且恢复正常执行流程。

package main

import "fmt"

func innerFunction() {
    // 内层函数执行 panic
    panic("panic from innerFunction")
}

func recoverDemo() (err error) {
    defer func() {
        if r := recover(); r != nil {
            // 恢复 panic，并将恢复的错误信息作为返回值返回
            err = fmt.Errorf("Recovered from panic: %v", r)
        }
    }()
    // 调用内层函数
    innerFunction()
    return nil
}

func main() {
    fmt.Println("Start")
    // 调用 recoverDemo 函数
    err := recoverDemo()
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("End")
}

对比Java，在 Go 中的 panic 和 recover 与 Java 中的 try-catch 是异常处理的两种不同机制，虽然目标相同，但处理方式不同。

Go 中的 panic 和 recover

• panic: 在 Go 中，panic 用于表示程序遇到了不可恢复的错误，类似于 Java 中的抛出异常。当程序调用 panic 函数时，它会立即停止执行，并开始沿调用栈回退，执行 defer 语句，直到所有的延迟函数执行完毕，然后程序终止。panic 通常用于表示程序遇到了无法处理的错误，比如空指针引用等。

• recover: recover 函数用于从 panic 中恢复程序的控制流，并阻止程序终止。当 recover 被调用时，它会返回传递给 panic 的参数值，并且恢复正常执行流程。recover 通常和 defer 一起使用，用于捕获 panic。

Java 中的 try-catch

• try-catch: 在 Java 中，try-catch 是用于异常处理的机制。try 语句块用于包含可能引发异常的代码，catch 语句块用于捕获并处理异常。当 try 语句块中的代码引发异常时，程序会跳转到 catch 语句块，并执行相应的异常处理代码。Java 中的异常分为可检查异常（checked exception）和不可检查异常（unchecked exception），try-catch 主要用于处理可检查异常，比如 IOException。

下面是一个简单的对比示例：

Go 中的 panic 和 recover：

package main

import "fmt"

func recoverDemo() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("panic demo")
}

func main() {
    fmt.Println("Start")
    recoverDemo()
    fmt.Println("End")
}

Java 中的 try-catch：

public class Main {
    public static void main(String[] args) {
        System.out.println("Start");
        try {
            throw new Exception("exception demo");
        } catch (Exception e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
        System.out.println("End");
    }
}

尽管两种语言都提供了异常处理机制，但是它们的实现方式有所不同。在 Go 中，panic 和 recover 的使用更加灵活，而在 Java 中，异常处理更加结构化，需要显式地使用 try-catch 块来捕获和处理异常。

GoSafe 和 RunSafe

可以使用GoSafe和RunSafe函数避免程序崩溃：

1. 使用GoSafe启动一个新的goroutine来执行一些可能会引发panic的代码：

threading.GoSafe(func() {
    // 这里是可能会引发panic的代码
    // 例如，尝试从一个可能为nil的map中获取值
    mapVar := make(map[string]string)
    value := mapVar["nonexistent_key"]
    fmt.Println(value)
})

在这个例子中，如果mapVar为nil，尝试从中获取值将会引发panic。但是，由于我们在GoSafe中运行这段代码，所以这个panic会被捕获，程序不会崩溃。

2. 使用RunSafe在当前goroutine中执行一些可能会引发panic的代码：

threading.RunSafe(func() {
    // 这里是可能会引发panic的代码
    // 例如，尝试从一个可能为nil的slice中获取元素
    var sliceVar []string
    element := sliceVar[0]
    fmt.Println(element)
})

在这个例子中，如果sliceVar为nil，尝试从中获取元素将会引发panic。但是，由于我们在RunSafe中运行这段代码，所以这个panic会被捕获，程序不会崩溃。

这些函数的主要目的是提供一种安全的方式来运行可能会引发panic的代码，使得即使在发生panic的情况下，也不会导致整个程序崩溃。