使用带有取消的上下文，Go 例程不会终止

Go语言中使用带有取消的上下文时，Go例程可能不会终止。这是因为found通道无缓冲，发送操作会阻塞，直到有人准备好接收为止。当main函数从found通道接收时，它会阻塞在waitgroup.wait()处，因为没有例程调用waitgroup.done()。这导致了僵局，因为例程无法在found通道上发送结果。

我是 go 和 go 并发性的新手。一旦找到具有给定 id 的成员，我就会尝试使用 go 上下文取消一组 go 例程。

组存储客户端列表，每个客户端都有一个成员列表。我想并行搜索所有客户及其所有会员，以查找具有给定 id 的会员。一旦找到这个成员，我想取消所有其他 go 例程并返回发现的成员。

我尝试了以下实现，使用 context.withcancel 和 waitgroup。

但这不起作用，并且无限期地挂起，永远不会越过 waitgroup.wait() 线，但我不确定到底为什么。

func (group *Group) MemberWithID(ID string) (*models.Member, error) {
    found := make(chan *models.Member)
    ctx := context.Background()
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()
    var waitGroup sync.WaitGroup

    for _, client := range group.Clients {
        waitGroup.Add(1)

        go func(clientToQuery Client) {
            defer waitGroup.Done()

            select {
            case <-ctx.Done():
                return
            default:
            }

            member, _ := client.ClientMemberWithID(ID)
            if member != nil {
                found <- member
                cancel()
                return
            }

        } (client)

    }

    waitGroup.Wait()

    if len(found) > 0 {
        return <-found, nil
    }

    return nil, fmt.Errorf("no member found with given id")
}

正确答案

found 是一个无缓冲通道，因此在它上发送会阻塞，直到有人准备好从它接收。

您的 main() 函数将是从中接收的函数，但仅在 waitgroup.wait() 返回之后。但这将会阻塞，直到所有启动的 goroutine 调用 waitgroup.done()。但直到他们回来之前这不会发生，直到他们可以在 found 上发送之前不会发生。这是一个僵局。

如果您将 found 更改为缓冲，则即使 main() 尚未准备好从中接收数据，也将允许在其上发送值（与缓冲区大小一样多的值）。

但是您应该在 waitgroup.wait() 返回之前收到来自 found 的消息。

另一个解决方案是对 found 使用缓冲区 1，并在 found 上使用非阻塞发送。这样，第一个（最快的）goroutine 将能够发送结果，其余的（假设我们使用非阻塞发送）将简单地跳过发送。

还要注意，应该是 main() 调用 cancel()，而不是每个单独启动的 goroutine。

对于这种用例，我认为 sync.once 可能是更好的选择适合比通道。当你找到第一个非零成员时，你想做两件不同的事情：

1. 记录您找到的成员。
2. 取消剩余的 goroutine。

缓冲通道可以轻松实现 (1)，但会使 (2) 变得更加复杂。但是 sync.once 非常适合在第一次发生有趣的事情时做两件不同的事情！

我还建议聚合非平凡的错误，以便您可以报告比 no memberfound 更有用的内容，例如，如果您的数据库连接失败或发生其他一些非平凡的错误。您也可以使用 sync.once 来实现！

把它们放在一起，我希望看到这样的东西（https://play.golang.org/p/QZXUUnbxOv5）：

func (group *Group) MemberWithID(ctx context.Context, id string) (*Member, error) {
    ctx, cancel := context.WithCancel(ctx)
    defer cancel()

    var (
        wg sync.WaitGroup

        member    *Member
        foundOnce sync.Once

        firstNontrivialErr error
        errOnce            sync.Once
    )

    for _, client := range group.Clients {
        wg.Add(1)
        client := client // https://golang.org/doc/faq#closures_and_goroutines
        go func() {
            defer wg.Done()

            m, err := client.ClientMemberWithID(ctx, id)
            if m != nil {
                foundOnce.Do(func() {
                    member = m
                    cancel()
                })
            } else if nf := (*MemberNotFoundError)(nil); !errors.As(err, &nf) {
                errOnce.Do(func() {
                    firstNontrivialErr = err
                })
            }
        }()
    }
    wg.Wait()

    if member == nil {
        if firstNontrivialErr != nil {
            return nil, firstNontrivialErr
        }
        return nil, &MemberNotFoundError{ID: id}
    }
    return member, nil
}

今天关于《使用带有取消的上下文，Go 例程不会终止》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！