golang 并发任务错误处理技术包括：1. 返回值传递错误；2. 抛出异常；3. 使用通道传递错误。实战案例包括并发文件读取和 http 请求，通过通道传递错误，提高代码健壮性。

Go 语言函数：并发任务执行中的错误处理技术

在 Golang 中使用并发函数执行任务时，处理错误至关重要。本文介绍了多种错误处理技术，并提供了有关如何将它们应用于实际场景的实战案例。

错误处理技术

1. 返回值

最简单的方法是使用返回值来传递错误。函数可以返回错误值，调用者可以检查该值并采取适当的措施。

func getSum(a, b int) (int, error) {
    if a < 0 || b < 0 {
        return 0, errors.New("inputs must be non-negative")
    }
    return a + b, nil
}

2. 抛出异常

Go 语言提供了一个内置的异常机制。可以使用 panic 函数抛出异常，由调用者使用 recover 函数捕获。

立即学习“go语言免费学习笔记（深入）”；

func getArea(width, height int) (int, error) {
    if width < 0 || height < 0 {
        panic("invalid width or height")
    }
    return width * height, nil
}

3. channel

通道提供了另一种用于并发任务错误处理的机制。可以创建一个接收错误的 channel，然后将该 channel 传递给任务 goroutine。如果任务出错，goroutine 将向 channel 发送错误。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

func getAverage(numbers []int) (float64, error) {
    errCh := make(chan error)

    go func() {
        sum := 0
        for _, n := range numbers {
            sum += n
        }

        avg := float64(sum) / float64(len(numbers))
        if len(numbers) == 0 {
            errCh <- errors.New("empty slice")
        } else {
            errCh <- nil
        }
    }()

    select {
    case err := <-errCh:
        return 0, err
    case <-time.After(1 * time.Second):
        return 0, errors.New("timeout")
    }
}

实战案例

文件读取并处理

以下函数使用并发 goroutine 读取并处理文件中的行。错误通过 channel 传递。

func processLines(filePath string) ([][]string, error) {
    errCh := make(chan error)

    file, err := os.Open(filePath)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    lines := [][]string{}
    nLines := 0

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        line := scanner.Text()
        nLines++

        go func(line string) {
            parts := strings.Split(line, ",")
            errCh <- processLine(parts)
        }(line)
    }

    for i := 0; i < nLines; i++ {
        err := <-errCh
        if err != nil {
            return nil, err
        }
    }

    return lines, nil
}

HTTP 请求并发

以下函数使用并发 goroutine 发出 HTTP 请求。错误通过返回的 channel 传递。

func sendRequests(urls []string) ([][]byte, error) {
    respCh := make(chan []byte, len(urls))
    errCh := make(chan error, len(urls))

    for _, url := range urls {
        go func(url string) {
            resp, err := http.Get(url)
            if err != nil {
                errCh <- err
            } else {
                defer resp.Body.Close()
                body, err := ioutil.ReadAll(resp.Body)
                if err != nil {
                    errCh <- err
                } else {
                    respCh <- body
                }
            }
        }(url)
    }

    responses := [][]byte{}
    for i := 0; i < len(urls); i++ {
        select {
        case resp := <-respCh:
            responses = append(responses, resp)
        case err := <-errCh:
            return nil, err
        }
    }

    return responses, nil
}

总结

通过了解并应用这些错误处理技术，您可以有效地在 Golang 并发任务中处理错误，从而提高代码的健壮性和可靠性。