为什么这个函数在golang中不是线程安全的？

Question

这是我提到的代码：

// this is inside some method which has return signature like this: (*Data, error)
mapStore := make(...)
resSlice := make(...)
wg := new(sync.WaitGroup)
ec := make(chan error)
for keyString, sliceValue := range myMap {
     wg.Add(1)

     keyString := keyString
     sliceValue := sliceValue

     go func() {
          err := func(keyString string, sliceValue []Value, wg *sync.WaitGroup) error {
                defer wg.Done()
                res, err := process(keyString, sliceValue)
                if err != nil {
                      return errors.Wrapf(err, "wrong")
                }
                if res == nil {
                      return nil
                }
                if res.someData != nil {
                      mapStore[*res.someData] = append(mapStore[*res.someData], res)
                      return nil
                }
                resSlice := append(resSlice, res)
                return nil
               }(keyString, sliceValue, wg)
               if err != nil {
                     ec <- err
                     return
               }
          }()
     }
}
wg.Wait()

select {
case err := <- ec:
      return nil, err
default:
      return resSlice, nil
}

我被告知出于某种原因这不是线程安全的，但我不确定在哪里。我认为这是在 ec 中处理错误的问题，但希望得到一些帮助！

Answer 1

我没有全部分析，但肯定是多个goroutine对mapStore的修改是不安全的：

mapStore[*res.someData] = append(mapStore[*res.someData], res)

但是作为起点，运行这个下race detector。它会帮你找出很多问题。

这显然也是不安全的：

resSlice := append(resSlice, res)

但它也不完全符合您的想法。这会创建一个名为 resSlice 的新局部变量，它会隐藏外部变量，但它也会修改外部变量（请参阅下面的注释）。除了两个东西可能会尝试同时追加并发生碰撞之外，append 可以在需要重新分配时将整个切片移动到内存中，因此即使您在其周围加锁，这也会导致线程安全问题.

通常，您不想让每个 goroutine 更新一些中央变量，而是希望让每个 goroutine 将其结果传回通道。然后让主函数收集所有值并更新变量。有关示例，请参阅 Go Concurrency Patterns: Pipelines and cancellation。

为什么这个函数在golang中不是线程安全的？

Why is this function not thread safe in golang?

go

parallel-processing

thread-safety

channel

goroutine