使用 Go 协程和通道来处理错误或成功情况

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《使用 Go 协程和通道来处理错误或成功情况》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我有一个函数，我想定义最大数量的 go 例程，我有一个列表，我浏览这个列表，然后通过通道向 go 例程发送消息，在这个 go 例程中我将调用一个函数，要么得到答案，要么得到错误，当它不是错误时，我想将返回保存在切片中，当它是错误时，我想停止 go 例程并进行调用。 但我无法做到这一点，以便当我出错时，所有 go 例程都会结束，并且我需要 err 的值

type response struct {
    value string
}

func Testing() []response {

    fakeValues := getFakeValues()

    maxParallel := 25
    wg := &sync.WaitGroup{}
    wg.Add(maxParallel)

    if len(fakeValues) < maxParallel {
        maxParallel = len(fakeValues)
    }

    errReceive := make(chan error, 1)
    defer close(errReceive)

    response := make([]response, 0)
    valuesChan := make(chan string, 1)

    for i := 0; i < maxParallel; i++ {
        go func(valuesChan <-chan string, errReceive chan error) {
            for value := range valuesChan {
                resp, err := getFakeResult(value)
                if err != nil {
                    errReceive <- err
                }

                response = append(response, resp)
            }
            wg.Done()
        }(valuesChan, errReceive)
    }

    for _, val := range fakeValues {
        valuesChan <- val
    }

    close(valuesChan)
    wg.Wait()

    err := <-errReceive
    if err != nil {
        // make any thing
    }

    return response
}

func getFakeValues() []string {
    return []string{"a", "b"}
}

func getFakeResult(val string) (response, error) {
    if val == "a" {
        return response{}, fmt.Errorf("ooh noh:%s", val)
    }

    return response{
        value: val,
    }, nil
}

正确答案

您可以使用带有取消的上下文，并使用它让 go 例程知道它们应该停止。

ctx, cancel := context.withcancel(context.background())
defer cancel()

wg := &sync.waitgroup{}
wg.add(1)
go func(ctx context.context) {
    defer wg.done()
    for {
        select {
        case <-ctx.done():
            fmt.println("context is done")
            return
        case <-time.after(time.second):
            fmt.println("work")
        }
    }
}(ctx)

time.sleep(time.second * 5)
cancel()
wg.wait()

https://go.dev/play/p/qe2oDppSnaF

这里是一个示例，可以在您的用例上下文中更好地展示它。

type result struct {
    err error
    val int
}

rand.Seed(time.Now().UnixNano())

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

rchan := make(chan result, 5)
wg := &sync.WaitGroup{}

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(ctx context.Context) {
        defer wg.Done()
        for {
            select {
            case <-ctx.Done():
                fmt.Println("context is done")
                return
            case <-time.After(time.Second):
                n := rand.Intn(100)
                if n > 90 {
                    rchan <- result{err: fmt.Errorf("error %d", n)}
                } else {
                    rchan <- result{val: n}
                }
            }
        }
    }(ctx)
}

go func() {
    wg.Wait()
    close(rchan)
}()

for res := range rchan {
    if res.err != nil {
        fmt.Println(res.err)
        cancel()
        break
    } else {
        fmt.Println(res.val)
    }
}

https://go.dev/play/p/Z63n1h2A81o

到这里，我们也就讲完了《使用 Go 协程和通道来处理错误或成功情况》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！