当您在具有并发访问的程序中使用映射时，是否需要在函数中使用互斥锁来读取值？
user1243746
问问题
83825 次
6 回答
111
多个读者，没有作家是可以的：
https://groups.google.com/d/msg/golang-nuts/HpLWnGTp-n8/hyUYmnWJqiQJ
一个作家，没有读者是好的。（否则地图不会很好。）
否则，如果至少有一个写入器，并且至少有一个写入器或读取器，则所有读取器和写入器都必须使用同步来访问映射。互斥体可以很好地解决这个问题。
于 2012-06-16T12:47:14.210 回答
59
sync.Map截至 2017 年 4 月 27 日，已合并到 Go master。
这是我们一直在等待的并发 Map。
于 2017-04-28T10:40:11.113 回答
24
几天前我在这个reddit线程中回答了你的问题：
在 Go 中，映射不是线程安全的。此外，即使读取数据也需要锁定，例如，如果可能有另一个 goroutine 正在写入相同的数据（即并发）。
从您在评论中的澄清来看，也会有 setter 函数，您的问题的答案是肯定的，您必须使用互斥锁来保护您的读取；您可以使用RWMutex。例如，您可以查看我编写的表数据结构（在后台使用地图）的实现源（实际上是在 reddit 线程中链接的那个）。
于 2012-06-16T18:27:59.827 回答
21
您可以使用concurrent-map来为您处理并发难题。
// Create a new map.
map := cmap.NewConcurrentMap()
// Add item to map, adds "bar" under key "foo"
map.Add("foo", "bar")
// Retrieve item from map.
tmp, ok := map.Get("foo")
// Checks if item exists
if ok == true {
// Map stores items as interface{}, hence we'll have to cast.
bar := tmp.(string)
}
// Removes item under key "foo"
map.Remove("foo")
于 2014-10-05T16:49:20.620 回答
3
如果你只有一个作家，那么你可能会使用原子值。以下改编自https://golang.org/pkg/sync/atomic/#example_Value_readMostly（原文使用锁来保护写，所以支持多写者）
type Map map[string]string
var m Value
m.Store(make(Map))
read := func(key string) (val string) { // read from multiple go routines
m1 := m.Load().(Map)
return m1[key]
}
insert := func(key, val string) { // update from one go routine
m1 := m.Load().(Map) // load current value of the data structure
m2 := make(Map) // create a new map
for k, v := range m1 {
m2[k] = v // copy all data from the current object to the new one
}
m2[key] = val // do the update that we need (can delete/add/change)
m.Store(m2) // atomically replace the current object with the new one
// At this point all new readers start working with the new version.
// The old version will be garbage collected once the existing readers
// (if any) are done with it.
}
于 2017-01-06T18:23:48.157 回答
0
为什么不使用 Go 并发模型，有一个简单的例子......
type DataManager struct {
/** This contain connection to know dataStore **/
m_dataStores map[string]DataStore
/** That channel is use to access the dataStores map **/
m_dataStoreChan chan map[string]interface{}
}
func newDataManager() *DataManager {
dataManager := new(DataManager)
dataManager.m_dataStores = make(map[string]DataStore)
dataManager.m_dataStoreChan = make(chan map[string]interface{}, 0)
// Concurrency...
go func() {
for {
select {
case op := <-dataManager.m_dataStoreChan:
if op["op"] == "getDataStore" {
storeId := op["storeId"].(string)
op["store"].(chan DataStore) <- dataManager.m_dataStores[storeId]
} else if op["op"] == "getDataStores" {
stores := make([]DataStore, 0)
for _, store := range dataManager.m_dataStores {
stores = append(stores, store)
}
op["stores"].(chan []DataStore) <- stores
} else if op["op"] == "setDataStore" {
store := op["store"].(DataStore)
dataManager.m_dataStores[store.GetId()] = store
} else if op["op"] == "removeDataStore" {
storeId := op["storeId"].(string)
delete(dataManager.m_dataStores, storeId)
}
}
}
}()
return dataManager
}
/**
* Access Map functions...
*/
func (this *DataManager) getDataStore(id string) DataStore {
arguments := make(map[string]interface{})
arguments["op"] = "getDataStore"
arguments["storeId"] = id
result := make(chan DataStore)
arguments["store"] = result
this.m_dataStoreChan <- arguments
return <-result
}
func (this *DataManager) getDataStores() []DataStore {
arguments := make(map[string]interface{})
arguments["op"] = "getDataStores"
result := make(chan []DataStore)
arguments["stores"] = result
this.m_dataStoreChan <- arguments
return <-result
}
func (this *DataManager) setDataStore(store DataStore) {
arguments := make(map[string]interface{})
arguments["op"] = "setDataStore"
arguments["store"] = store
this.m_dataStoreChan <- arguments
}
func (this *DataManager) removeDataStore(id string) {
arguments := make(map[string]interface{})
arguments["storeId"] = id
arguments["op"] = "removeDataStore"
this.m_dataStoreChan <- arguments
}
于 2018-02-23T21:30:58.630 回答