在Golang中如何处理goroutine因panic导致的异常退出

defer

recover()

defer

recover()

recover()

defer

defer

recover()

package main

import (
    "fmt"
    "runtime/debug"
    "time"
)

// safeGo是一个辅助函数，用于启动一个带有panic恢复机制的goroutine
func safeGo(f func()) {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                // 在这里处理捕获到的panic
                fmt.Printf("一个goroutine发生panic并被恢复了！错误信息：%v\n", r)
                // 打印堆栈信息，这对于调试非常重要
                debug.PrintStack()
                // 可以选择在这里发送错误通知，或者记录到日志系统
                // log.Printf("Goroutine panicked: %v, stack: %s", r, debug.Stack())
            }
        }()
        f() // 执行传入的函数
    }()
}

func main() {
    fmt.Println("主程序开始运行...")

    // 启动一个会panic的goroutine
    safeGo(func() {
        fmt.Println("Goroutine 1: 我要开始做一些危险的事情了...")
        time.Sleep(time.Second) // 模拟一些工作
        panic("Oops! Goroutine 1 出错了！") // 模拟一个panic
    })

    // 启动另一个正常的goroutine
    safeGo(func() {
        fmt.Println("Goroutine 2: 我会正常完成我的任务。")
        time.Sleep(3 * time.Second)
        fmt.Println("Goroutine 2: 任务完成。")
    })

    // 主程序继续执行，不会因为Goroutine 1的panic而中断
    time.Sleep(5 * time.Second)
    fmt.Println("主程序运行结束。")
}

safeGo

defer

recover()

Goroutine 1

main

Goroutine 2

recover()

debug.PrintStack()

panic

recover

main

defer recover

defer

recover

package main

import (
    "fmt"
    "log"
    "runtime/debug"
    "time"
)

// WorkerResult 用于传递worker goroutine的执行结果或错误
type WorkerResult struct {
    ID    int
    Error error
}

func safeWorker(id int, task func(), resultChan chan<- WorkerResult) {
    go func() {
        defer func() {
            if r := recover(); r != nil {
                err := fmt.Errorf("worker %d panicked: %v", id, r)
                log.Printf("ERROR: %v\nStack: %s", err, debug.Stack())
                // 将错误信息发送到结果通道
                resultChan <- WorkerResult{ID: id, Error: err}
                // 可以在这里触发告警
                // alertService.SendAlert(err.Error())
            }
        }()
        log.Printf("Worker %d: 开始执行任务...", id)
        task()
        log.Printf("Worker %d: 任务完成。", id)
        resultChan <- WorkerResult{ID: id, Error: nil}
    }()
}

func main() {
    log.SetFlags(log.LstdFlags | log.Lshortfile)
    fmt.Println("主程序启动，准备启动多个worker...")

    resultChan := make(chan WorkerResult, 3) // 缓冲通道，用于接收worker结果

    // 启动一个会panic的worker
    safeWorker(1, func() {
        time.Sleep(1 * time.Second)
        var s []int
        fmt.Println(s[10]) // 模拟一个索引越界 panic
    }, resultChan)

    // 启动一个正常完成的worker
    safeWorker(2, func() {
        time.Sleep(2 * time.Second)
        fmt.Println("我是Worker 2，我正常完成了我的工作。")
    }, resultChan)

    // 启动另一个会panic的worker
    safeWorker(3, func() {
        time.Sleep(3 * time.Second)
        panic("Worker 3: 模拟一个自定义 panic 错误！")
    }, resultChan)

    // 等待所有worker的结果
    finishedWorkers := 0
    for finishedWorkers < 3 {
        select {
        case res := <-resultChan:
            if res.Error != nil {
                fmt.Printf("主程序收到Worker %d的错误报告: %v\n", res.ID, res.Error)
            } else {
                fmt.Printf("主程序收到Worker %d的任务完成通知。\n", res.ID)
            }
            finishedWorkers++
        case <-time.After(6 * time.Second): // 设置一个超时，防止死锁
            fmt.Println("等待worker超时，可能有些worker未完成。")
            finishedWorkers = 3 // 退出循环
        }
    }

    fmt.Println("所有worker处理完毕，主程序退出。")
}

resultChan

defer

recover

recover