Was sollte man beim Arbeiten mit Mutexes in Go beachten?

Bei der Arbeit mit Mutexen (sync.Mutex) in Go ist es wichtig, Folgendes zu beachten:

• Sperren und Freigeben: Der Mutex muss unbedingt (Lock()) vor dem Zugriff auf gemeinsam genutzte Daten gesperrt und (Unlock()) nach Abschluss freigegeben werden. Die Verwendung von defer mu.Unlock() direkt nach mu.Lock() ist eine gute Praxis, um das Vergessen der Freigabe zu vermeiden.
• Exklusiver Zugriff: Der Mutex gewährt nur einem Goroutine gleichzeitig exklusiven Zugriff auf eine Ressource.
• Zustand "gesperrt/entsperrt": Ein erneuter Aufruf von Lock() auf einem bereits gesperrten Mutex führt dazu, dass die aufrufende Goroutine blockiert, bis der Mutex von einer anderen Goroutine freigegeben wird. Ein Unlock() auf einem nicht gesperrten Mutex verursacht einen Laufzeit-Panic.
• Mutexe nicht kopieren: Die Struktur sync.Mutex ist nicht dafür vorgesehen, kopiert zu werden, nachdem sie einmal verwendet wurde. Das Übergeben eines Mutex per Wert oder das Kopieren der Struktur, die den Mutex enthält, kann zu falscher Synchronisation und Panics führen.
• Deadlocks (Verklemmungen): Tritt auf, wenn zwei oder mehr Goroutines aufeinander warten, um Ressourcen freizugeben. Typisches Szenario: Goroutine A sperrt R1 und wartet auf R2, während Goroutine B R2 sperrt und auf R1 wartet.
• Livelocks (lebende Sperren): Situation, in der Goroutines ständig ihren Zustand ändern, um auf Aktionen anderer zu reagieren, ohne nützliche Arbeit zu verrichten oder voranzukommen. Dies ist seltener als Deadlock.
• Starvation (Verhungern): Situation, in der eine oder mehrere Goroutines keinen Zugriff auf eine gemeinsam genutzte Ressource erhalten, weil sie ständig von anderen Goroutines blockiert wird. Bei Go-Mutexen ist Hunger nicht garantiert.
• Verwendung von sync.RWMutex für Lesen/Schreiben: Wenn die meisten Operationen Lesezugriffe sind und Schreibzugriffe selten vorkommen, kann sync.RWMutex effizienter sein. Es erlaubt mehreren Goroutines, gleichzeitig zu lesen, blockiert aber bei Schreibzugriffen.
• Kurze Sperren: Versuchen Sie, Sperren so kurz wie möglich zu halten. Je länger ein Mutex gesperrt ist, desto mehr Goroutines warten, was die Parallelität verringert.
• Race-Condition-Tests: Die Verwendung des Flags -race beim Kompilieren und Ausführen von Tests (go test -race) hilft, Race Conditions zu erkennen, die oft durch falsche Mutex-Nutzung verursacht werden.

Beispiel für die Verwendung von defer:

import (
	"sync"
)

type SafeCounter struct {
	mu sync.Mutex
	v  map[string]int
}

// Inc erhöht sicher den Zähler für einen Schlüssel.
func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()
	// Freigabe beim Verlassen der Funktion.
	defer c.mu.Unlock()
	c.v[key]++
}

// Value gibt den aktuellen Wert des Zählers für einen Schlüssel zurück.
func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	// Freigabe nach Wertabfrage.
	defer c.mu.Unlock()
	return c.v[key]
}