Mapa con acceso simultáneo

Question

Cuando utiliza un mapa en un programa con acceso simultáneo, ¿hay alguna necesidad de utilizar un mutex en las funciones para leer los valores?

Answer 1

múltiples lectores, escritores no está bien:

https://groups.google.com/d/msg/golang-nuts/HpLWnGTp-n8/hyUYmnWJqiQJ

Un escritor, no hay lectores está bien. (Los mapas no sería mucho más bueno de lo contrario.)

De lo contrario, si hay al menos un escritor y al menos uno más, ya sea escritor o lector, entonces todos los lectoresy escritores deben utilizar la sincronización para acceder al mapa . Un mutex funciona bien para esto.

Answer 2

me respondió su pregunta en this hilo reddit Hace pocos días:

En Go, los mapas no son seguros para subprocesos. Además, los datos requieren el bloqueo incluso para leyendo si, por ejemplo, podría haber otra goroutine que es escribiendo los mismos datos (al mismo tiempo, eso es).

A juzgar por su aclaración en los comentarios, que también van a haber funciones de colocador, la respuesta a su pregunta es sí, tendrá que proteger sus lecturas con un mutex; puede usar un RWMutex. Para un ejemplo, puede ver el source de la implementación de una estructura de datos de tablas (utiliza un mapa detrás de las escenas) que escribí (en realidad, el vinculado en el hilo de reddit).

Answer 3

Puede usar concurrent-map para controlar los problemas de concurrencia.

// 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") 

Answer 4

si solo tiene un escritor, entonces probablemente pueda salirse con la suya con un valor atómico. La siguiente es una adaptación de https://golang.org/pkg/sync/atomic/#example_Value_readMostly (el original utiliza bloqueos para proteger la escritura, por lo que es compatible con varios escritores)

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. 
    } 

Answer 5

sync.Map ha fusionado a libre Maestro el 27 de abril, 2017.

Este es el mapa de concurrentes que todos han estado esperando.

https://github.com/golang/go/blob/master/src/sync/map.go

https://godoc.org/sync#Map

Answer 6

¿Por qué no se hizo uso de Go modelo de concurrencia en su lugar, hay un ejemplo sencillo ...

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 
}