怎样在Golang中处理并发环境下的错误 解决goroutine错误传递问题

chan error

sync.WaitGroup

chan error

sync.WaitGroup

wg.Wait()

wg.Wait()

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(id int, errCh chan<- error, wg *sync.WaitGroup) {
    defer wg.Done() // 确保无论如何都通知WaitGroup
    fmt.Printf("Worker %d started\n", id)
    time.Sleep(time.Duration(id) * 100 * time.Millisecond) // 模拟工作耗时

    if id%2 != 0 { // 模拟奇数ID的worker会出错
        errCh <- fmt.Errorf("worker %d failed with a simulated error", id)
        return
    }
    fmt.Printf("Worker %d finished successfully\n", id)
}

func main() {
    numWorkers := 5
    var wg sync.WaitGroup
    errCh := make(chan error, numWorkers) // 缓冲通道，避免发送方阻塞

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go worker(i, errCh, &wg)
    }

    // 启动一个goroutine来等待所有worker完成，然后关闭错误通道
    go func() {
        wg.Wait()
        close(errCh) // 所有worker都完成了，可以关闭错误通道了
    }()

    // 收集错误
    var allErrors []error
    for err := range errCh { // 循环直到通道关闭
        allErrors = append(allErrors, err)
        fmt.Printf("Collected error: %v\n", err)
    }

    fmt.Println("\nAll workers finished.")
    if len(allErrors) > 0 {
        fmt.Println("Summary of errors:")
        for _, err := range allErrors {
            fmt.Println("-", err)
        }
    } else {
        fmt.Println("No errors reported.")
    }
}

context.Context

context

context.WithCancel

context.Context

WithCancel

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

func cancellableWorker(id int, ctx context.Context, errCh chan<- error, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Cancellable Worker %d started\n", id)

    select {
    case <-time.After(time.Duration(id+1) * 200 * time.Millisecond): // 模拟工作耗时
        if id == 2 { // 模拟特定worker出错并触发取消
            err := fmt.Errorf("worker %d hit a critical error, cancelling all!", id)
            select {
            case errCh <- err: // 尝试发送错误
            case <-ctx.Done(): // 如果上下文已经取消，说明错误通道可能已经关闭或不再被监听
                fmt.Printf("Worker %d tried to send error but context already done: %v\n", id, ctx.Err())
            }
            return // 错误发生，worker退出
        }
        fmt.Printf("Cancellable Worker %d finished successfully\n", id)
    case <-ctx.Done(): // 监听取消信号
        fmt.Printf("Cancellable Worker %d received cancellation signal: %v\n", id, ctx.Err())
        return // 收到取消信号，立即退出
    }
}

func main() {
    numWorkers := 5
    var wg sync.WaitGroup
    errCh := make(chan error, 1) // 缓冲为1，只关心第一个错误

    // 创建一个可取消的上下文
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 确保在main函数退出时调用cancel，释放资源

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go cancellableWorker(i, ctx, errCh, &wg)
    }

    // 启动一个goroutine来监听错误，并在收到错误时取消上下文
    go func() {
        select {
        case err := <-errCh:
            fmt.Printf("\nCritical error received: %v. Cancelling all workers...\n", err)
            cancel() // 收到错误，立即取消所有goroutine
        case <-time.After(1 * time.Second): // 如果在1秒内没有错误，也取消（可选，防止死锁或长时间等待）
            fmt.Println("\nNo critical error after 1 second, proceeding to wait for workers.")
            cancel() // 也可以选择不取消，只等待wg.Wait()
        }
    }()

    wg.Wait() // 等待所有worker完成或被取消
    fmt.Println("\nAll cancellable workers finished or cancelled.")

    // 如果有错误被发送到errCh，但主goroutine已经通过ctx.Done()退出，
    // 那么errCh可能不会被读取。需要根据实际情况决定如何处理。
    // 这里的例子中，errCh只用于触发取消，不用于汇总所有错误。
}

cancel()

ctx.Done()

cancel()

<-ctx.Done()

errors.Is

errors.As

panic

panic

error

recover

panic

panic

defer

recover

error