Wie kann man in einer Multithread-Umgebung eine sichere Arbeit mit der Map-Sammlung gewährleisten?

In Go ist die Standardkarte (map) nicht thread-sicher für gleichzeitiges Lesen und Schreiben aus verschiedenen Goroutinen. Um eine sichere Arbeit mit der Map in einer Multithread-Umgebung zu gewährleisten, können die folgenden Ansätze verwendet werden:

1. Synchronisation mit Mutex

Verwenden Sie sync.Mutex oder sync.RWMutex, um den Zugriff auf die Map zu schützen. Beim Schreiben sperren Sie den Mutex für Schreibzugriffe, beim Lesen — für Lesezugriffe (wenn Sie RWMutex verwenden).

import "sync"

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

func (s *SafeMap) Get(key string) (int, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    val, ok := s.m[key]
    return val, ok
}

func (s *SafeMap) Set(key string, val int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.m[key] = val
}

2. Verwendung von sync.Map

In Go gibt es eine spezialisierte Struktur sync.Map, die für den gleichzeitigen Zugriff optimiert ist und keine manuelle Synchronisation erfordert.

import "sync"

var m sync.Map

// Schreiben
m.Store("key", 42)

// Lesen
val, ok := m.Load("key")

3. Verwendung von Kanälen (channels)

Man kann den Zugriff auf die Map durch eine Goroutine organisieren, die Anfragen zum Lesen und Schreiben über Kanäle verarbeitet und so einen sequenziellen Zugriff gewährleistet.

Die Wahl der Methode hängt von den spezifischen Anforderungen an Leistung und Implementierungsaufwand ab.