Sperren Sie die Karte für den gleichzeitigen Zugriff auf die Karte

php-Editor Baicao ist hier, um Ihnen eine sehr nützliche Technik vorzustellen, die darin besteht, die Karte für den gleichzeitigen Zugriff zu sperren. Diese Technik kann Entwicklern helfen, Konflikte und Datenfehler beim gleichzeitigen Zugriff auf die Karte zu vermeiden. Durch die Verwendung eines Sperrmechanismus können Entwickler sicherstellen, dass jede Anfrage in der richtigen Reihenfolge erfolgt und kein Datenchaos entsteht. Dies ist für die Entwicklung von Kartenoperationen sehr wichtig, insbesondere wenn mehrere Benutzer gleichzeitig auf die Karte zugreifen. Werfen wir einen Blick darauf, wie man diese Technik umsetzt!

Frageninhalt

Ich habe eine Karte: map[string]map[string]*Struct und ich muss sie in mehreren Go-Routinen lesen/schreiben.

Was ist der beste Weg, dies zu erreichen? Mutex oder RWMutex? Und wo soll es platziert werden?

Wenn ich RWMutex verwende, sollte ich vor dem Ausführen von Lese- und Schreibvorgängen sperren oder sperren?

Ich habe versucht, rwmutex in der Root-Map zu verwenden, bin mir aber nicht sicher, ob dies der beste Weg ist, dieses Problem zu lösen.

Ich habe auch versucht, vor dem Lesen und Schreiben zu „sperren“, aber manchmal bekomme ich „gleichzeitige Schreibvorgänge“-Panik.

Workaround

Sie können RWLock verwenden. Wenn der Vorgang das Schreiben beinhaltet (unabhängig davon, ob es sich um ein Lesen oder nur um ein Schreiben handelt), müssen Sie Lock verwenden. Wenn es sich nur um einen Lesevorgang handelt, müssen Sie RLock/RUnlock verwenden.

Schloss kann auch als exklusives Schloss betrachtet werden. RLock hingegen ist nicht exklusiv. Ein RLock kann auch dann erworben werden, wenn der RWMutex zum Lesen gesperrt ist, aber die Goroutine-Ausführung wird blockiert, wenn die Ressource ausschließlich durch die Lock-Methode gesperrt ist:

a blocked Lock call excludes new readers from acquiring the lock

Andererseits blockiert die Lock-Methode die Ausführung von Goroutinen, bis alle Leser und Autoren die Ressource entsperren (mithilfe der RUnlock/Unlock-Methode). Lock ist exklusiv, da nur eine Goroutine auf die Ressource zugreifen kann (ob lesend oder schreibend), bis die Unlock-Methode aufgerufen wird.

Typische Methode:

package main

import (
    "fmt"
    "sync"
)

type SomeStruct struct {
    someInfo string
}

type ConcurrentStruct struct {
    mu   sync.RWMutex
    data map[string]map[string]*SomeStruct
}

func New() *ConcurrentStruct {
    return &ConcurrentStruct{
        data: make(map[string]map[string]*SomeStruct),
    }
}

func (cs *ConcurrentStruct) Set(key1, key2 string, val SomeStruct) {
    cs.mu.Lock()
    defer cs.mu.Unlock()

    if _, ok := cs.data[key1]; !ok {
        cs.data[key1] = make(map[string]*SomeStruct)
    }
    cs.data[key1][key2] = &val
}

func (cs *ConcurrentStruct) Get(key1, key2 string) (val *SomeStruct, ok bool) {
    cs.mu.RLock()
    defer cs.mu.RUnlock()

    if _, ok := cs.data[key1]; ok {
        val, ok := cs.data[key1][key2]
        return val, ok
    }

    return nil, false
}

func main() {
    cs := New()
    cs.Set("a", "b", SomeStruct{"Hello, World!"})

    if _, ok := cs.Get("a", "c"); !ok {
        fmt.Printf("key1=a, key2=c, not found\n")
    }

    if s, ok := cs.Get("a", "b"); ok {
        fmt.Printf("key1=a, key2=b, found: %v\n", s)
    }
}

Das obige ist der detaillierte Inhalt vonSperren Sie die Karte für den gleichzeitigen Zugriff auf die Karte. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!