我们应该在 goroutine 中同步变量赋值吗？

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《我们应该在 goroutine 中同步变量赋值吗？》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

假设我声明了两个映射，并希望将其分配到错误组中的两个不同的 goroutine 中。我不执行任何读/写。 我应该使用 lock 保护分配操作还是可以省略它？

upd3：在 brian goetz 的《java 并发实践》第 i 部分第 3 章 shared objects 中，提到：

锁定不仅仅意味着互斥，还意味着互斥。这也是记忆 能见度。确保所有线程都能看到最新的值 对于共享可变变量，读取和写入线程必须 在公共锁上同步。

var (
    mu     sync.Mutex
    one    map[string]struct{}
    two    map[string]struct{}
)
g, gctx := errgroup.WithContext(ctx)
g.Go(func() error {
    resp, err := invokeFirstService(gctx, request)
    if err != nil {
        return err
    }
    mu.Lock()
    one = resp.One
    mu.Unlock()
    return nil
})

g.Go(func() error {
    resp, err := invokeSecondService(gctx, request)
    if err != nil {
        return err
    }
    mu.Lock()
    two = resp.Two
    mu.Unlock()
    return nil
})
if err := g.Wait(); err != nil {
    return err
}
// UPD3: added lock and unlock section
m.Lock()
defer m.Unlock()
performAction(one, two)

upd：添加了有关变量的更多上下文

upd2：我的疑问是什么：我们有 3 个 goroutine - 父级和错误组中的两个。无法保证我们的父 goroutine 共享内存在 errgroup goroutines 完成后获得最后的更新，直到我们用内存屏障包装对共享内存的访问

解决方案

Group.Wait() 会阻塞，直到 Group.Go() 方法的所有函数调用都返回为止，因此这是一个同步点。这确保 performaction(one, two) 在对 one 和 two 的任何写入完成之前不会启动，因此在您的示例中互斥体是不必要的。

g, gctx := errgroup.withcontext(ctx)
g.go(func() error {
    // ...
    one = resp.one
    return nil
})

g.go(func() error {
    // ...
    two = resp.two
    return nil
})

if err := g.wait(); err != nil {
    return err
}
// here you can access one and two safely:
performaction(one, two)

如果您要从其他 goroutines 访问 one 和 two，而编写它们的 goroutines 并发运行，那么是的，您需要锁定它们，例如：

// This goroutine runs concurrently, so all concurrent access must be synchronized:
go func() {
    mu.Lock()
    fmt.Println(one, two)
    mu.Unlock()
}()

g, gctx := errgroup.WithContext(ctx)
g.Go(func() error {
    // ...
    mu.Lock()
    one = resp.One
    mu.Unlock()
    return nil
})

g.Go(func() error {
    // ...
    mu.Lock()
    two = resp.Two
    mu.Unlock()
    return nil
})

if err := g.Wait(); err != nil {
    return err
}
// Note that you don't need to lock here
// if the first concurrent goroutine only reads one and two.
performAction(one, two)

另请注意，在上面的示例中，您可以使用 sync.RWMutex，并且在读取它们的 goroutine 中，RWMutex.RLock() 和 RWMutex.RUnlock() 也足够了。

今天关于《我们应该在 goroutine 中同步变量赋值吗？》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！