Карта с одновременным доступом

Question

Когда вы используете карту в программе с параллельным доступом, существует ли необходимость использовать мьютекс в функциях для , чтобы читать значения?

Answer 1

Несколько читателей, не писатели не в порядке:

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

Один писатель, нет читателей не в порядке. (Карты не будут прока иначе.)

В противном случае, если есть хотя бы один писатель и по крайней мере, еще ни писателю или читателя один, то всех читателей и писателей должны использовать синхронизацию, чтобы получить доступ к карте , Мьютекс отлично подходит для этого.

Answer 2

Я ответил на ваш вопрос в this Reddit нити несколько дней назад:

В Go, карты не потокобезопасные. Кроме того, данные требуют блокировки даже для чтения , если, например, может быть другой горутин, который является , записывая одни и те же данные (одновременно).

Судя по пояснениям в комментариях, что есть функции setter, ответ на ваш вопрос да, вы должны будете защитить свои чтения с помощью мьютекса; вы можете использовать RWMutex. В качестве примера вы можете посмотреть на source реализации структуры данных таблицы (использует карту за кулисами), которую я написал (фактически тот, что связан в потоке reddit).

Answer 3

Вы можете использовать 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") 

Answer 4

Если у вас только один писатель, то вы, вероятно, можете уйти от использования атомного значения. Заимствован из 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. 
    } 

Answer 5

sync.Map слился Пойти мастер по состоянию на 27 апреля, 2017.

Это параллельная карта мы все ждали.

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

https://godoc.org/sync#Map

Answer 6

Почему не использовал модель 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 
}