Wie schützt man sich vor Fehlern bei gleichzeitiger…

Zum Schutz vor Fehlern bei gleichzeitigen Schreibvorgängen in map in Golang, die standardmäßig nicht thread-sicher sind, werden folgende Mechanismen verwendet:

sync.Mutex: Sperrt die Map vor dem Schreiben und entsperrt sie danach.

import "sync"

type SafeMap struct {
    mu sync.Mutex
    data map[string]int
}

func NewSafeMap() *SafeMap {
    return &SafeMap{
        data: make(map[string]int),
    }
}

func (sm *SafeMap) Set(key string, value int) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
    sm.mu.Lock()
    defer sm.mu.Unlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.RWMutex: Ermöglicht gleichzeitiges Lesen aus der Map durch mehrere Goroutines, sperrt aber das Schreiben bei gleichzeitigen Lese- oder Schreibzugriffen.

import "sync"

type SafeMapRWMutex struct {
    mu sync.RWMutex
    data map[string]int
}

func NewSafeMapRWMutex() *SafeMapRWMutex {
    return &SafeMapRWMutex{
        data: make(map[string]int),
    }
}

func (sm *SafeMapRWMutex) Set(key string, value int) {
    sm.mu.Lock() // Schreibsperre
    defer sm.mu.Unlock()
    sm.data[key] = value
}

func (sm *SafeMapRWMutex) Get(key string) (int, bool) {
    sm.mu.RLock() // Lesesperre
    defer sm.mu.RUnlock()
    val, ok := sm.data[key]
    return val, ok
}

sync.Map: Spezieller thread-sicherer Typ, optimiert für Szenarien, in denen der Schlüsselbereich relativ stabil ist und Schreibzugriffe selten sind, oder wenn mehrere Goroutines für disjunkte Schlüsselsets lesen und schreiben.

import "sync"

var safeMap sync.Map // Deklaration

func UseSyncMap() {
    safeMap.Store("key1", 10) // Schreiben
    if val, ok := safeMap.Load("key1"); ok { // Lesen
        // Verwendung von val
    }
    safeMap.Delete("key1") // Löschen
}

Vergleich der Ansätze:

Mechanismus	Vorteile	Nachteile	Anwendung
`sync.Mutex`	Einfach zu verwenden	Sperrt alle Operationen beim Schreiben	Einfache Szenarien, bei denen die gleichzeitige Zugriffe nicht hoch sind oder Lesen/Schreiben ungefähr gleich sind.
`sync.RWMutex`	Ermöglicht paralleles Lesen	Komplexer als `sync.Mutex`. Schreiben sperrt Lesen und andere Schreiben.	Szenarien mit häufigem Lesen und seltenem Schreiben.
`sync.Map`	Für bestimmte Szenarien optimiert	Hat eine eingeschränkte API. Kann langsamer sein als `Mutex`, wenn der Zugriff vollständig zufällig ist.	Szenarien mit relativ stabilen Schlüsseln oder disjunkten Schlüsselsets für verschiedene Goroutines.

Die Wahl eines bestimmten Ansatzes hängt von der Art des gleichzeitigen Zugriffs auf die Map ab. Für allgemeine Fälle sind oft sync.Mutex oder sync.RWMutex ausreichend. Für spezielle Szenarien kann sync.Map bessere Leistung bieten.

Wie schützt man sich vor Fehlern bei gleichzeitiger Schreiboperation in einer Map?