Wie erreicht man Thread-Sicherheit in Go: Mutexe, Atomics oder Kanäle?

So implementieren Sie Thread-Sicherheit für Variablen in Go

In Java stellt das Konzept synchronisierter Variablen sicher, dass nur ein einzelner Thread ausgeführt werden kann einen bestimmten Codeblock zu einem bestimmten Zeitpunkt. Go bietet jedoch kein explizites synchronisiertes Schlüsselwort an.

Begründung

Go fördert einen anderen Ansatz zur Thread-Synchronisierung, der sich an dem Prinzip orientiert: „Kommunizieren Sie nicht durch Teilen.“ Gedächtnis teilen; stattdessen Gedächtnis durch Kommunikation teilen.“ Dies bedeutet, dass Sie den direkten Zugriff auf den gemeinsamen Speicher vermeiden und sich für kommunikationsbasierte Mechanismen wie Kanäle entscheiden müssen.

Mutex-basierte Synchronisierung

Sollten Sie auf ein Szenario stoßen, in dem ein Mutex erforderlich ist? , hier erfahren Sie, wie Sie es implementieren Gehen Sie:

var (
    mu        sync.Mutex
    protectMe int
)

func getMe() int {
    mu.Lock()
    me := protectMe
    mu.Unlock()
    return me
}

func setMe(me int) {
    mu.Lock()
    protectMe = me
    mu.Unlock()
}

Verbesserungen

• Konvertieren Sie sync.Mutex in sync.RWMutex, um gleichzeitigen Lesezugriff zu ermöglichen.
• Erwägen Sie die Verwendung von defer um Ressourcenlecks im Fehlerfall zu vermeiden.
• Betten Sie den Mutex in den geschützten Bereich ein Wert, um die Lesbarkeit und den Komfort des Codes zu verbessern.

Atomic Synchronization

Wenn Sie einen einzelnen Wert schützen müssen, ziehen Sie die Verwendung des sync/atomic-Pakets in Betracht:

var protectMe int32

func getMe() int32 {
    return atomic.LoadInt32(&protectMe)
}

func setMe(me int32) {
    atomic.StoreInt32(&protectMe, me)
}

Kommunikationsbasierter Ansatz

Los fördert die Nutzung von Kanälen für die Kommunikation zwischen Goroutinen, wodurch die Notwendigkeit gemeinsamer Variablen entfällt. Zum Beispiel in einem Publisher-Subscriber-Muster:

type topic struct {
    subscribing []chan int
}

var t = &topic{}

func subscribe() chan int {
    ch := make(chan int)
    t.subscribing = append(t.subscribing, ch)
    return ch
}

func publish(v int) {
    for _, ch := range t.subscribing {
        ch <- v
    }
}

Dieser Ansatz gewährleistet eine threadsichere Kommunikation ohne gemeinsame Nutzung von Speicher.

Das obige ist der detaillierte Inhalt vonWie erreicht man Thread-Sicherheit in Go: Mutexe, Atomics oder Kanäle?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!