Golang中如何实现panic的恢复与重试机制

Golang中如何实现panic的恢复与重试机制 如何从 panic 中恢复并继续执行（例如，从中断处恢复）？可以尝试以下方式（伪代码）：

func main() { 
   ...code
   defer errorfix()
   ....code..
   ....'overflow' panic
   ....code...
   ....'divide by zero' panic
   ....code...
}

func errorfix() {
   if err := recover(); err !=nil { 
     ... fix something based on err and then 
     return to retry
     // or return to next line
     // or panic('unknown error')
   }
}

更多关于Golang中如何实现panic的恢复与重试机制的实战教程也可以访问 https://www.itying.com/category-94-b0.html

3 回复

考虑将代码嵌入匿名函数中，这样发生 panic 时，通过 defer 恢复机制只会退出该函数。

更多关于Golang中如何实现panic的恢复与重试机制的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


我认为不是这样。一旦当前程序遇到panic，它会回收你的函数（在你的代码中是main()）已申请的栈空间，因此你将没有机会这样做。

在Go语言中，可以通过recover()函数在defer中捕获panic，但需要注意recover()只能在defer函数中生效。对于需要重试的场景，可以结合循环和错误类型判断来实现。以下是几种实现方式：

1. 基础panic恢复机制

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Recovered from panic: %v\n", r)
            // 执行清理操作或记录日志
        }
    }()
    
    // 可能触发panic的代码
    riskyOperation()
}

func riskyOperation() {
    // 模拟可能panic的操作
    var arr []int
    fmt.Println(arr[5]) // 这里会触发panic
}

2. 带重试机制的panic恢复

func main() {
    maxRetries := 3
    for i := 0; i < maxRetries; i++ {
        fmt.Printf("Attempt %d: ", i+1)
        success := executeWithRecovery(riskyOperation)
        if success {
            fmt.Println("Operation completed successfully")
            break
        }
        if i == maxRetries-1 {
            fmt.Println("All retries failed")
        }
    }
}

func executeWithRecovery(fn func()) bool {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Panic recovered: %v\n", r)
        }
    }()
    
    fn()
    return true
}

func riskyOperation() {
    // 模拟可能panic的操作
    rand.Seed(time.Now().UnixNano())
    if rand.Intn(3) == 0 {
        panic("random panic occurred")
    }
    fmt.Println("Operation succeeded")
}

3. 基于错误类型的智能恢复

func main() {
    operations := []func(){
        divideOperation,
        sliceOperation,
        customPanicOperation,
    }
    
    for i, op := range operations {
        fmt.Printf("Operation %d: ", i+1)
        executeWithSmartRecovery(op)
    }
}

func executeWithSmartRecovery(fn func()) {
    defer func() {
        if r := recover(); r != nil {
            switch err := r.(type) {
            case string:
                if err == "divide by zero" {
                    fmt.Println("Handled divide by zero panic, using default value")
                    // 设置默认值并继续
                } else if err == "index out of range" {
                    fmt.Println("Handled index out of range, using safe access")
                    // 使用安全访问方式
                } else {
                    fmt.Printf("Unknown panic: %s\n", err)
                }
            case runtime.Error:
                fmt.Printf("Runtime error: %v\n", err)
            default:
                fmt.Printf("Unexpected panic: %v\n", err)
            }
        }
    }()
    
    fn()
}

func divideOperation() {
    var a, b int = 10, 0
    result := a / b // 会触发panic
    fmt.Printf("Result: %d\n", result)
}

func sliceOperation() {
    arr := []int{1, 2, 3}
    fmt.Printf("Element: %d\n", arr[5]) // 会触发panic
}

func customPanicOperation() {
    panic("custom error message")
}

4. 上下文感知的恢复机制

type OperationContext struct {
    Name     string
    Attempts int
    Success  bool
}

func main() {
    ctx := &OperationContext{Name: "CriticalOperation", Attempts: 0}
    
    for ctx.Attempts < 5 && !ctx.Success {
        ctx.Attempts++
        executeWithContext(ctx, criticalOperation)
        time.Sleep(100 * time.Millisecond) // 重试前等待
    }
    
    if ctx.Success {
        fmt.Printf("Operation '%s' succeeded after %d attempts\n", ctx.Name, ctx.Attempts)
    } else {
        fmt.Printf("Operation '%s' failed after %d attempts\n", ctx.Name, ctx.Attempts)
    }
}

func executeWithContext(ctx *OperationContext, fn func(*OperationContext)) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("Attempt %d failed: %v\n", ctx.Attempts, r)
            // 可以根据panic类型更新上下文
            if err, ok := r.(string); ok {
                ctx.Name = fmt.Sprintf("%s_recovered_from_%s", ctx.Name, err)
            }
        }
    }()
    
    fn(ctx)
    ctx.Success = true
}

func criticalOperation(ctx *OperationContext) {
    fmt.Printf("Executing %s (attempt %d)\n", ctx.Name, ctx.Attempts)
    
    // 模拟可能失败的操作
    if ctx.Attempts < 3 {
        panic("operation failed")
    }
    
    fmt.Println("Operation completed successfully")
}

关键要点：

  1. recover()必须在defer函数中调用
  2. 无法直接从panic发生处恢复执行，只能阻止panic向上传播
  3. 重试机制需要结合循环和状态管理
  4. 可以根据panic的具体类型实现不同的恢复策略
  5. 对于不可恢复的错误，应该重新panic或返回错误

这些模式可以根据具体业务需求进行调整和扩展。

回到顶部