如何在Golang中使用channel来传递和处理来自goroutine的错误

error

package main

import (
    "errors"
    "fmt"
    "time"
)

// doSomethingRisky 模拟一个可能失败的操作
func doSomethingRisky(id int) error {
    if id%2 != 0 {
        return fmt.Errorf("goroutine %d: 模拟一个奇数ID的错误", id)
    }
    time.Sleep(50 * time.Millisecond) // 模拟一些工作
    return nil
}

func main() {
    // 创建一个error类型的channel
    errCh := make(chan error, 1) // 缓冲区大小1，防止goroutine发送错误时阻塞

    go func() {
        err := doSomethingRisky(1) // 这是一个会产生错误的ID
        if err != nil {
            errCh <- err // 将错误发送到channel
        }
        // 如果没有错误，这里可以选择不发送任何东西，或者发送一个nil来表示完成，但通常不发送nil更简洁
    }()

    // 在主goroutine中接收错误
    select {
    case err := <-errCh:
        if err != nil {
            fmt.Printf("主goroutine接收到错误: %v\n", err)
        } else {
            fmt.Println("主goroutine接收到nil错误 (理论上不会发生，因为我们只发送非nil错误)")
        }
    case <-time.After(200 * time.Millisecond): // 设置一个超时，以防goroutine永远不返回
        fmt.Println("操作超时，未收到错误或成功信号。")
    }

    fmt.Println("主程序继续执行...")
}

chan error

package main

import (
    "errors"
    "fmt"
    "time"
)

func worker(id int, errCh chan<- error) { // 使用chan<- error表示只发送
    fmt.Printf("Worker %d 开始工作...\n", id)
    time.Sleep(time.Duration(id) * 100 * time.Millisecond) // 模拟不同耗时

    if id%2 != 0 { // 模拟奇数ID出错
        errCh <- fmt.Errorf("worker %d 遇到了一个错误", id)
        return
    }
    fmt.Printf("Worker %d 完成工作。\n", id)
    // 成功时不发送任何东西，这是一种常见的实践
}

func main() {
    errChan := make(chan error, 1) // 缓冲区大小1，避免worker阻塞

    go worker(1, errChan) // 这个会出错
    go worker(2, errChan) // 这个会成功

    // 等待一段时间，看是否有错误发生
    select {
    case err := <-errChan:
        fmt.Printf("主程序捕获到错误: %v\n", err)
    case <-time.After(500 * time.Millisecond): // 设定一个超时
        fmt.Println("所有worker可能都已完成，或未在规定时间内报告错误。")
    }

    fmt.Println("主程序继续执行其余任务...")
    time.Sleep(1 * time.Second) // 确保所有goroutine有时间完成
}

chan<- error

sync.WaitGroup

package main

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

// performTask 模拟一个可能失败的任务
func performTask(id int) error {
    time.Sleep(time.Duration(id) * 100 * time.Millisecond) // 模拟不同耗时
    if id%3 == 0 { // 模拟部分任务会失败
        return fmt.Errorf("任务 %d 失败了", id)
    }
    fmt.Printf("任务 %d 完成。\n", id)
    return nil
}

func main() {
    numTasks := 5
    var wg sync.WaitGroup
    errCh := make(chan error, numTasks) // 缓冲区大小设置为任务数，确保所有错误都能被发送

    for i := 1; i <= numTasks; i++ {
        wg.Add(1)
        go func(taskID int) {
            defer wg.Done()
            if err := performTask(taskID); err != nil {
                errCh <- err
            }
        }(i)
    }

    // 启动一个goroutine来关闭errCh
    // 这样做是为了确保在所有wg.Done()都执行完毕后，errCh才会被关闭
    go func() {
        wg.Wait() // 等待所有任务goroutine完成
        close(errCh) // 关闭错误channel，通知接收者不会再有新的错误了
    }()

    // 收集所有错误
    var allErrors []error
    for err := range errCh { // 循环直到errCh被关闭
        allErrors = append(allErrors, err)
    }

    if len(allErrors) > 0 {
        fmt.Println("\n检测到以下错误:")
        for _, err := range allErrors {
            fmt.Printf("- %v\n", err)
        }
    } else {
        fmt.Println("\n所有任务成功完成，未检测到错误。")
    }

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

WaitGroup

close(errCh)

for err := range errCh

WaitGroup