/*
03-panic-recover.go - Go 语言 Panic 和 Recover 详解

学习目标：
1. 理解 panic 的概念和使用场景
2. 掌握 recover 的恢复机制
3. 学会 defer 与 panic/recover 的配合
4. 了解 panic 的传播机制
5. 掌握 panic/recover 的最佳实践

知识点：
- panic 的触发条件和行为
- recover 的恢复机制
- defer 语句的执行顺序
- panic 的传播和栈展开
- panic/recover 的实际应用
- 错误处理 vs panic 的选择
*/

package main

import (
	"fmt"
	"runtime"
	"strconv"
	"time"
)

func main() {
	fmt.Println("=== Go 语言 Panic 和 Recover 详解 ===\\n")

	// 演示 panic 的基本概念
	demonstratePanicBasics()

	// 演示 recover 的使用
	demonstrateRecover()

	// 演示 defer 与 panic/recover 的配合
	demonstrateDeferWithPanicRecover()

	// 演示 panic 的传播
	demonstratePanicPropagation()

	// 演示 panic/recover 的实际应用
	demonstratePracticalUsage()

	// 演示最佳实践
	demonstrateBestPractices()

	// 演示错误处理 vs panic 的选择
	demonstrateErrorVsPanic()
}

// demonstratePanicBasics 演示 panic 的基本概念
func demonstratePanicBasics() {
	fmt.Println("1. Panic 的基本概念:")

	// panic 的基本特性
	fmt.Printf("   Panic 的基本特性:\\n")
	fmt.Printf("     - panic 是运行时错误，会导致程序崩溃\\n")
	fmt.Printf("     - panic 会停止当前函数的执行\\n")
	fmt.Printf("     - panic 会执行当前函数的 defer 语句\\n")
	fmt.Printf("     - panic 会向上传播到调用栈\\n")
	fmt.Printf("     - panic 可以被 recover 捕获\\n")

	// 手动触发 panic
	fmt.Printf("   手动触发 panic:\\n")

	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     捕获到 panic: %v\\n", r)
			}
		}()

		fmt.Printf("     准备触发 panic\\n")
		panic("这是一个手动触发的 panic")
		fmt.Printf("     这行代码不会执行\\n")
	}()

	// 常见的 panic 场景
	fmt.Printf("   常见的 panic 场景:\\n")

	// 1. 数组越界
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     数组越界 panic: %v\\n", r)
			}
		}()

		arr := [3]int{1, 2, 3}
		fmt.Printf("     访问数组索引 5: %d\\n", arr[5]) // 会 panic
	}()

	// 2. 空指针解引用
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     空指针解引用 panic: %v\\n", r)
			}
		}()

		var ptr *int
		fmt.Printf("     解引用空指针: %d\\n", *ptr) // 会 panic
	}()

	// 3. 类型断言失败
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     类型断言失败 panic: %v\\n", r)
			}
		}()

		var x interface{} = "hello"
		num := x.(int) // 会 panic
		fmt.Printf("     类型断言结果: %d\\n", num)
	}()

	// 4. 向已关闭的 channel 发送数据
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     向已关闭 channel 发送数据 panic: %v\\n", r)
			}
		}()

		ch := make(chan int)
		close(ch)
		ch <- 1 // 会 panic
	}()

	fmt.Println()
}

// demonstrateRecover 演示 recover 的使用
func demonstrateRecover() {
	fmt.Println("2. Recover 的使用:")

	// recover 的基本概念
	fmt.Printf("   Recover 的基本概念:\\n")
	fmt.Printf("     - recover 只能在 defer 函数中使用\\n")
	fmt.Printf("     - recover 可以捕获当前 goroutine 的 panic\\n")
	fmt.Printf("     - recover 返回 panic 的值\\n")
	fmt.Printf("     - recover 后程序可以继续执行\\n")

	// 基本 recover 示例
	fmt.Printf("   基本 recover 示例:\\n")

	result := safeFunction(func() int {
		panic("计算过程中发生错误")
		return 42
	})
	fmt.Printf("     安全函数返回: %d\\n", result)

	// recover 的返回值
	fmt.Printf("   recover 的返回值:\\n")

	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     panic 值: %v\\n", r)
				fmt.Printf("     panic 类型: %T\\n", r)

				// 根据 panic 类型进行不同处理
				switch v := r.(type) {
				case string:
					fmt.Printf("     字符串 panic: %s\\n", v)
				case int:
					fmt.Printf("     整数 panic: %d\\n", v)
				case error:
					fmt.Printf("     错误 panic: %v\\n", v)
				default:
					fmt.Printf("     其他类型 panic: %v\\n", v)
				}
			}
		}()

		// 触发不同类型的 panic
		testPanics := []interface{}{
			"字符串错误",
			42,
			fmt.Errorf("错误对象"),
			struct{ Message string }{"结构体错误"},
		}

		for i, panicValue := range testPanics {
			func() {
				defer func() {
					if r := recover(); r != nil {
						fmt.Printf("     测试 %d - panic: %v (%T)\\n", i+1, r, r)
					}
				}()
				panic(panicValue)
			}()
		}
	}()

	// recover 的条件
	fmt.Printf("   recover 的条件:\\n")

	// 正确的 recover 使用
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     正确捕获 panic: %v\\n", r)
			}
		}()
		panic("正确的 recover 示例")
	}()

	// 错误的 recover 使用
	func() {
		defer func() {
			// 这个 recover 不会捕获到 panic，因为不是直接在 defer 中调用
			go func() {
				if r := recover(); r != nil {
					fmt.Printf("     错误的 recover: %v\\n", r)
				}
			}()
		}()

		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     正确捕获嵌套 panic: %v\\n", r)
			}
		}()

		panic("嵌套 panic 示例")
	}()

	fmt.Println()
}

// demonstrateDeferWithPanicRecover 演示 defer 与 panic/recover 的配合
func demonstrateDeferWithPanicRecover() {
	fmt.Println("3. Defer 与 Panic/Recover 的配合:")

	// defer 的执行顺序
	fmt.Printf("   defer 的执行顺序:\\n")

	func() {
		defer fmt.Printf("     defer 1\\n")
		defer fmt.Printf("     defer 2\\n")
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     recover: %v\\n", r)
			}
		}()
		defer fmt.Printf("     defer 3\\n")

		fmt.Printf("     正常执行\\n")
		panic("测试 defer 顺序")
		fmt.Printf("     这行不会执行\\n")
	}()

	// 多层 defer 和 recover
	fmt.Printf("   多层 defer 和 recover:\\n")

	func() {
		defer func() {
			fmt.Printf("     外层 defer 开始\\n")
			if r := recover(); r != nil {
				fmt.Printf("     外层 recover: %v\\n", r)
			}
			fmt.Printf("     外层 defer 结束\\n")
		}()

		defer func() {
			fmt.Printf("     内层 defer 开始\\n")
			defer func() {
				if r := recover(); r != nil {
					fmt.Printf("     内层 recover: %v\\n", r)
				}
			}()
			fmt.Printf("     内层 defer 结束\\n")
		}()

		panic("多层 defer 测试")
	}()

	// defer 中的资源清理
	fmt.Printf("   defer 中的资源清理:\\n")

	processWithCleanup := func() {
		// 模拟资源分配
		resource := "重要资源"
		fmt.Printf("     分配资源: %s\\n", resource)

		defer func() {
			// 资源清理
			fmt.Printf("     清理资源: %s\\n", resource)

			// 捕获 panic
			if r := recover(); r != nil {
				fmt.Printf("     处理过程中发生 panic: %v\\n", r)
				fmt.Printf("     资源已安全清理\\n")
			}
		}()

		// 模拟可能 panic 的操作
		if time.Now().UnixNano()%2 == 0 {
			panic("随机 panic")
		}

		fmt.Printf("     正常处理完成\\n")
	}

	// 执行多次以演示不同情况
	for i := 0; i < 3; i++ {
		fmt.Printf("     执行 %d:\\n", i+1)
		processWithCleanup()
	}

	fmt.Println()
}

// demonstratePanicPropagation 演示 panic 的传播
func demonstratePanicPropagation() {
	fmt.Println("4. Panic 的传播:")

	// panic 的栈展开
	fmt.Printf("   panic 的栈展开:\\n")

	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     最终捕获 panic: %v\\n", r)

				// 打印调用栈
				buf := make([]byte, 1024)
				n := runtime.Stack(buf, false)
				fmt.Printf("     调用栈:\\n%s\\n", buf[:n])
			}
		}()

		level1()
	}()

	// panic 的中途拦截
	fmt.Printf("   panic 的中途拦截:\\n")

	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     最外层捕获: %v\\n", r)
			}
		}()

		interceptedLevel1()
	}()

	// panic 的重新抛出
	fmt.Printf("   panic 的重新抛出:\\n")

	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("     最终处理 panic: %v\\n", r)
			}
		}()

		rethrowLevel1()
	}()

	fmt.Println()
}

// demonstratePracticalUsage 演示 panic/recover 的实际应用
func demonstratePracticalUsage() {
	fmt.Println("5. Panic/Recover 的实际应用:")

	// Web 服务器中的 panic 恢复
	fmt.Printf("   Web 服务器中的 panic 恢复:\\n")

	requests := []string{
		"/api/users",
		"/api/panic",
		"/api/orders",
		"/api/error",
	}

	for _, path := range requests {
		handleHTTPRequest(path)
	}

	// 工作池中的 panic 处理
	fmt.Printf("   工作池中的 panic 处理:\\n")

	jobs := []Job{
		{ID: 1, Data: "正常任务"},
		{ID: 2, Data: "panic任务"},
		{ID: 3, Data: "正常任务"},
		{ID: 4, Data: "error任务"},
	}

	for _, job := range jobs {
		processJobSafely(job)
	}

	// 数据解析中的 panic 处理
	fmt.Printf("   数据解析中的 panic 处理:\\n")

	data := []string{
		"123",
		"abc",
		"456",
		"",
		"789",
	}

	for _, item := range data {
		result := parseIntSafely(item)
		fmt.Printf("     解析 '%s': %d\\n", item, result)
	}

	// 递归函数中的 panic 处理
	fmt.Printf("   递归函数中的 panic 处理:\\n")

	testValues := []int{5, -1, 10, 0}
	for _, n := range testValues {
		result := safeFactorial(n)
		fmt.Printf("     %d! = %d\\n", n, result)
	}

	fmt.Println()
}

// demonstrateBestPractices 演示最佳实践
func demonstrateBestPractices() {
	fmt.Println("6. 最佳实践:")

	// 最佳实践原则
	fmt.Printf("   最佳实践原则:\\n")
	fmt.Printf("     1. 优先使用错误返回值而不是 panic\\n")
	fmt.Printf("     2. 只在真正异常的情况下使用 panic\\n")
	fmt.Printf("     3. 在库代码中避免 panic，转换为错误\\n")
	fmt.Printf("     4. 在应用边界使用 recover 保护\\n")
	fmt.Printf("     5. 记录 panic 信息用于调试\\n")

	// 库函数的 panic 处理
	fmt.Printf("   库函数的 panic 处理:\\n")

	// 不好的做法：库函数直接 panic
	fmt.Printf("     不好的做法示例:\\n")
	result, err := callLibraryFunction("invalid")
	if err != nil {
		fmt.Printf("       库函数错误: %v\\n", err)
	} else {
		fmt.Printf("       库函数结果: %s\\n", result)
	}

	// 好的做法：将 panic 转换为错误
	fmt.Printf("     好的做法示例:\\n")
	result, err = safeLibraryFunction("invalid")
	if err != nil {
		fmt.Printf("       安全库函数错误: %v\\n", err)
	} else {
		fmt.Printf("       安全库函数结果: %s\\n", result)
	}

	// panic 信息的记录
	fmt.Printf("   panic 信息的记录:\\n")

	func() {
		defer func() {
			if r := recover(); r != nil {
				logPanic(r)
			}
		}()

		panic("需要记录的 panic")
	}()

	// 优雅的服务关闭
	fmt.Printf("   优雅的服务关闭:\\n")

	server := &Server{name: "测试服务器"}
	server.Start()

	// 模拟服务运行中的 panic
	func() {
		defer server.handlePanic()
		panic("服务运行时错误")
	}()

	server.Stop()

	fmt.Println()
}

// demonstrateErrorVsPanic 演示错误处理 vs panic 的选择
func demonstrateErrorVsPanic() {
	fmt.Println("7. 错误处理 vs Panic 的选择:")

	// 使用错误的场景
	fmt.Printf("   使用错误的场景:\\n")
	fmt.Printf("     - 预期可能发生的错误\\n")
	fmt.Printf("     - 用户输入错误\\n")
	fmt.Printf("     - 网络或I/O错误\\n")
	fmt.Printf("     - 业务逻辑错误\\n")

	// 使用 panic 的场景
	fmt.Printf("   使用 panic 的场景:\\n")
	fmt.Printf("     - 程序逻辑错误\\n")
	fmt.Printf("     - 不可恢复的错误\\n")
	fmt.Printf("     - 初始化失败\\n")
	fmt.Printf("     - 断言失败\\n")

	// 对比示例
	fmt.Printf("   对比示例:\\n")

	// 错误处理示例
	fmt.Printf("     错误处理示例:\\n")
	result, err := divide(10, 0)
	if err != nil {
		fmt.Printf("       除法错误: %v\\n", err)
	} else {
		fmt.Printf("       除法结果: %.2f\\n", result)
	}

	// panic 示例
	fmt.Printf("     panic 示例:\\n")
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Printf("       捕获 panic: %v\\n", r)
			}
		}()

		assertPositive(-5)
	}()

	// 混合使用示例
	fmt.Printf("   混合使用示例:\\n")

	calculator := &Calculator{}

	// 正常计算
	result, err = calculator.Calculate("10 + 5")
	if err != nil {
		fmt.Printf("       计算错误: %v\\n", err)
	} else {
		fmt.Printf("       计算结果: %.2f\\n", result)
	}

	// 无效表达式
	result, err = calculator.Calculate("invalid")
	if err != nil {
		fmt.Printf("       计算错误: %v\\n", err)
	} else {
		fmt.Printf("       计算结果: %.2f\\n", result)
	}

	// 内部 panic 被转换为错误
	result, err = calculator.Calculate("panic")
	if err != nil {
		fmt.Printf("       计算错误: %v\\n", err)
	} else {
		fmt.Printf("       计算结果: %.2f\\n", result)
	}

	fmt.Println()
}

// ========== 辅助函数和类型定义 ==========

// safeFunction 安全执行函数
func safeFunction(fn func() int) int {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("     函数执行中发生 panic，已恢复: %v\\n", r)
		}
	}()

	return fn()
}

// level1 第一层函数
func level1() {
	defer func() {
		fmt.Printf("     level1 defer 执行\\n")
	}()

	fmt.Printf("     进入 level1\\n")
	level2()
	fmt.Printf("     level1 正常结束\\n")
}

// level2 第二层函数
func level2() {
	defer func() {
		fmt.Printf("     level2 defer 执行\\n")
	}()

	fmt.Printf("     进入 level2\\n")
	level3()
	fmt.Printf("     level2 正常结束\\n")
}

// level3 第三层函数
func level3() {
	defer func() {
		fmt.Printf("     level3 defer 执行\\n")
	}()

	fmt.Printf("     进入 level3\\n")
	panic("level3 中的 panic")
	fmt.Printf("     level3 正常结束\\n")
}

// interceptedLevel1 中途拦截的第一层
func interceptedLevel1() {
	defer func() {
		fmt.Printf("     interceptedLevel1 defer\\n")
	}()

	fmt.Printf("     进入 interceptedLevel1\\n")
	interceptedLevel2()
	fmt.Printf("     interceptedLevel1 正常结束\\n")
}

// interceptedLevel2 中途拦截的第二层
func interceptedLevel2() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("     interceptedLevel2 拦截 panic: %v\\n", r)
			// 不重新抛出，panic 在这里被处理
		}
		fmt.Printf("     interceptedLevel2 defer\\n")
	}()

	fmt.Printf("     进入 interceptedLevel2\\n")
	interceptedLevel3()
	fmt.Printf("     interceptedLevel2 正常结束\\n")
}

// interceptedLevel3 中途拦截的第三层
func interceptedLevel3() {
	defer func() {
		fmt.Printf("     interceptedLevel3 defer\\n")
	}()

	fmt.Printf("     进入 interceptedLevel3\\n")
	panic("interceptedLevel3 中的 panic")
	fmt.Printf("     interceptedLevel3 正常结束\\n")
}

// rethrowLevel1 重新抛出的第一层
func rethrowLevel1() {
	defer func() {
		fmt.Printf("     rethrowLevel1 defer\\n")
	}()

	fmt.Printf("     进入 rethrowLevel1\\n")
	rethrowLevel2()
	fmt.Printf("     rethrowLevel1 正常结束\\n")
}

// rethrowLevel2 重新抛出的第二层
func rethrowLevel2() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("     rethrowLevel2 捕获并重新抛出 panic: %v\\n", r)
			panic(fmt.Sprintf("重新抛出: %v", r)) // 重新抛出
		}
		fmt.Printf("     rethrowLevel2 defer\\n")
	}()

	fmt.Printf("     进入 rethrowLevel2\\n")
	rethrowLevel3()
	fmt.Printf("     rethrowLevel2 正常结束\\n")
}

// rethrowLevel3 重新抛出的第三层
func rethrowLevel3() {
	defer func() {
		fmt.Printf("     rethrowLevel3 defer\\n")
	}()

	fmt.Printf("     进入 rethrowLevel3\\n")
	panic("rethrowLevel3 中的 panic")
	fmt.Printf("     rethrowLevel3 正常结束\\n")
}

// handleHTTPRequest 处理HTTP请求
func handleHTTPRequest(path string) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("       HTTP请求 %s 发生 panic，已恢复: %v\\n", path, r)
			// 在实际应用中，这里会返回 500 错误
		}
	}()

	fmt.Printf("       处理请求: %s\\n", path)

	switch path {
	case "/api/panic":
		panic("模拟处理器 panic")
	case "/api/error":
		// 这里应该返回错误而不是 panic
		fmt.Printf("       请求处理出错\\n")
	default:
		fmt.Printf("       请求处理成功\\n")
	}
}

// Job 任务结构
type Job struct {
	ID   int
	Data string
}

// processJobSafely 安全处理任务
func processJobSafely(job Job) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("       任务 %d 处理时发生 panic，已恢复: %v\\n", job.ID, r)
		}
	}()

	fmt.Printf("       处理任务 %d: %s\\n", job.ID, job.Data)

	switch job.Data {
	case "panic任务":
		panic("任务处理中的 panic")
	case "error任务":
		fmt.Printf("       任务处理出错\\n")
	default:
		fmt.Printf("       任务处理成功\\n")
	}
}

// parseIntSafely 安全解析整数
func parseIntSafely(s string) int {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("         解析 '%s' 时发生 panic: %v\\n", s, r)
		}
	}()

	if s == "" {
		panic("空字符串无法解析")
	}

	result, err := strconv.Atoi(s)
	if err != nil {
		return 0 // 返回默认值
	}

	return result
}

// safeFactorial 安全计算阶乘
func safeFactorial(n int) int {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("         计算 %d! 时发生 panic: %v\\n", n, r)
		}
	}()

	return factorial(n)
}

// factorial 计算阶乘（可能 panic）
func factorial(n int) int {
	if n < 0 {
		panic("负数没有阶乘")
	}
	if n == 0 || n == 1 {
		return 1
	}
	return n * factorial(n-1)
}

// callLibraryFunction 库函数（不好的做法）
func callLibraryFunction(input string) (string, error) {
	// 这个函数直接 panic，不是好的做法
	if input == "invalid" {
		panic("库函数中的 panic")
	}
	return "处理结果: " + input, nil
}

// safeLibraryFunction 安全的库函数
func safeLibraryFunction(input string) (result string, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("库函数内部错误: %v", r)
		}
	}()

	// 调用可能 panic 的函数
	return callLibraryFunction(input)
}

// logPanic 记录 panic 信息
func logPanic(r interface{}) {
	fmt.Printf("     [PANIC LOG] 时间: %s\\n", time.Now().Format("2006-01-02 15:04:05"))
	fmt.Printf("     [PANIC LOG] 错误: %v\\n", r)
	fmt.Printf("     [PANIC LOG] 类型: %T\\n", r)

	// 获取调用栈
	buf := make([]byte, 1024)
	n := runtime.Stack(buf, false)
	fmt.Printf("     [PANIC LOG] 调用栈:\\n%s\\n", buf[:n])
}

// Server 服务器结构
type Server struct {
	name string
}

func (s *Server) Start() {
	fmt.Printf("     服务器 %s 启动\\n", s.name)
}

func (s *Server) Stop() {
	fmt.Printf("     服务器 %s 停止\\n", s.name)
}

func (s *Server) handlePanic() {
	if r := recover(); r != nil {
		fmt.Printf("     服务器 %s 捕获 panic: %v\\n", s.name, r)
		fmt.Printf("     服务器继续运行\\n")
	}
}

// divide 除法运算
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不能为零")
	}
	return a / b, nil
}

// assertPositive 断言为正数
func assertPositive(n int) {
	if n <= 0 {
		panic(fmt.Sprintf("断言失败: %d 不是正数", n))
	}
	fmt.Printf("       断言通过: %d 是正数\\n", n)
}

// Calculator 计算器
type Calculator struct{}

func (c *Calculator) Calculate(expression string) (result float64, err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("计算表达式 '%s' 时发生内部错误: %v", expression, r)
		}
	}()

	switch expression {
	case "10 + 5":
		return 15, nil
	case "invalid":
		return 0, fmt.Errorf("无效的表达式: %s", expression)
	case "panic":
		panic("计算器内部 panic")
	default:
		return 0, fmt.Errorf("不支持的表达式: %s", expression)
	}
}

/*
运行这个程序：
go run 03-panic-recover.go

学习要点：
1. panic 是运行时错误，会导致程序崩溃
2. recover 只能在 defer 函数中使用来捕获 panic
3. defer 语句按照 LIFO 顺序执行
4. panic 会沿着调用栈向上传播
5. panic/recover 应该谨慎使用，优先使用错误处理

Panic 的特性：
1. 停止当前函数的正常执行
2. 执行当前函数的所有 defer 语句
3. 向上传播到调用函数
4. 如果没有被 recover，程序会崩溃
5. 可以携带任意类型的值

Recover 的特性：
1. 只能在 defer 函数中直接调用
2. 返回 panic 的值，如果没有 panic 返回 nil
3. 只能捕获当前 goroutine 的 panic
4. 捕获后程序可以继续执行
5. 可以根据 panic 值进行不同处理

常见的 Panic 场景：
1. 数组或切片越界访问
2. 空指针解引用
3. 类型断言失败（不安全断言）
4. 向已关闭的 channel 发送数据
5. 除零操作（整数除法）

使用场景：
1. Panic 适用场景：
   - 程序逻辑错误
   - 不可恢复的错误
   - 初始化失败
   - 断言失败

2. Error 适用场景：
   - 预期可能发生的错误
   - 用户输入错误
   - 网络或I/O错误
   - 业务逻辑错误

最佳实践：
1. 优先使用错误返回值而不是 panic
2. 只在真正异常的情况下使用 panic
3. 在库代码中避免 panic，转换为错误
4. 在应用边界使用 recover 保护
5. 记录 panic 信息用于调试
6. 使用 defer 进行资源清理

注意事项：
1. recover 只能在 defer 中直接调用
2. 不要忽略 recover 的返回值
3. panic 会影响程序性能
4. 过度使用 panic/recover 会使代码难以理解
5. 在 goroutine 中的 panic 需要单独处理

实际应用：
1. Web 服务器的 panic 恢复中间件
2. 工作池中的任务 panic 处理
3. 数据解析中的异常处理
4. 递归函数的栈溢出保护
5. 库函数的 panic 转错误

性能考虑：
1. panic/recover 有一定的性能开销
2. 不应该用于正常的控制流
3. 频繁的 panic/recover 会影响性能
4. 错误处理通常比 panic/recover 更高效
5. 在性能敏感的代码中谨慎使用
*/