Question

现在我有一个仅包含一个写入/删除goroutine和许多read goroutine的映射，Map with concurrent access上有一些解决方案，例如RWMutex，sync.map，concurrent-map，sync.atomic，sync .Value，对我来说最好的选择是什么？

RWMutex的读取锁有点多余

sync.map和并发映射专注于许多写goroutines

Answer 1

您的问题有点含糊-因此，我将其分解。

我应该为地图使用哪种形式的并发访问？

选择取决于您在地图上需要的性能。我会选择一种基于简单互斥量（或RWMutex）的方法。

当然，您可以从concurrent map获得更好的性能。 sync.Mutex锁定了地图存储桶的所有所有，而在并发映射中，每个存储桶都有自己的sync.Mutex。

再次-这完全取决于程序的规模和所需的性能。

我如何使用互斥锁进行并发访问？

要确保正确使用地图，可以将其包装在struct中。

type Store struct {
    Data              map[T]T
}

这是一个面向对象的解决方案，但是它使我们能够确保同时执行任何读/写操作。除此之外，我们可以轻松存储其他可能对调试或安全性有用的信息，例如作者。

现在，我们将使用一组类似的方法来实现这一点：

mux sync.Mutex

// New initialises a Store type with an empty map
func New(t, h uint) *Store {
    return &Store{
        Data:     map[T]T{},
    }
}

// Insert adds a new key i to the store and places the value of x at this location
// If there is an error, this is returned - if not, this is nil
func (s *Store) Insert(i, x T) error {
    mux.Lock()
    defer mux.Unlock()
    _, ok := s.Data[i]
    if ok {
        return fmt.Errorf("index %s already exists; use update", i)
    }
    s.Data[i] = x
    return nil
}

// Update changes the value found at key i to x
// If there is an error, this is returned - if not, this is nil
func (s *Store) Update(i, x T) error {
    mux.Lock()
    defer mux.Unlock()
    _, ok := s.Data[i]
    if !ok {
        return fmt.Errorf("value at index %s does not exist; use insert", i)
    }
    s.Data[i] = x
    return nil
}

// Fetch returns the value found at index i in the store
// If there is an error, this is returned - if not, this is nil
func (s *Store) Fetch(i T) (T, error) {
    mux.Lock()
    defer mux.Unlock()
    v, ok := s.Data[i]
    if !ok {
        return "", fmt.Errorf("no value for key %s exists", i)
    }
    return v, nil
}

// Delete removes the index i from store
// If there is an error, this is returned - if not, this is nil
func (s *Store) Delete(i T) (T, error) {
    mux.Lock()
    defer mux.Unlock()
    v, ok := s.Data[i]
    if !ok {
        return "", fmt.Errorf("index %s already empty", i)
    }
    delete(s.Data, i)
    return v, nil
}

在我的解决方案中，我使用了一个简单的sync.Mutex-但您可以简单地更改此代码以适应RWMutex。

我建议您看看How to use RWMutex in Golang?。

如何解决Golang地图的并发访问？

1 个答案: