Go Accès simultané aux cartes


Exemple

Les cartes in go ne sont pas sûres pour la concurrence. Vous devez prendre un verrou pour lire et écrire dessus si vous y accédez simultanément. Généralement, la meilleure option consiste à utiliser sync.RWMutex car vous pouvez avoir des verrous en lecture et en écriture. Cependant, un sync.Mutex pourrait également être utilisé.

type RWMap struct {
    sync.RWMutex
    m map[string]int
}

// Get is a wrapper for getting the value from the underlying map
func (r RWMap) Get(key string) int {
    r.RLock()
    defer r.RUnlock()
    return r.m[key]
}

// Set is a wrapper for setting the value of a key in the underlying map
func (r RWMap) Set(key string, val int) {
    r.Lock()
    defer r.Unlock()
    r.m[key] = val
}

// Inc increases the value in the RWMap for a key.
//   This is more pleasant than r.Set(key, r.Get(key)++)
func (r RWMap) Inc(key string) {
    r.Lock()
    defer r.Unlock()
    r.m[key]++
}

func main() {

    // Init
    counter := RWMap{m: make(map[string]int)}

    // Get a Read Lock
    counter.RLock()
    _ = counter.["Key"]
    counter.RUnlock()

    // the above could be replaced with
    _ = counter.Get("Key")

    // Get a write Lock
    counter.Lock()
    counter.m["some_key"]++
    counter.Unlock()

    // above would need to be written as 
    counter.Inc("some_key")
}

Le compromis entre les fonctions d'encapsulation se situe entre l'accès public de la carte sous-jacente et l'utilisation correcte des verrous appropriés.