Wie kann man eine Deadlock-Situation in einem Go-Programm vermeiden?

Der gegenseitige Block in Go tritt am häufigsten bei unsachgemäßem Gebrauch von Mutexen und Kanälen auf. Er kann auf folgende Weisen vermieden werden:

• Geordneter Erwerb von Mutexen: Beim Erwerb mehrerer Mutexes, immer in derselben Reihenfolge in allen Goroutinen.
• Timeouts bei Sperren: Verwenden Sie Kontexte mit Timeouts beim Warten auf Sperren oder beim Empfang aus Kanälen, um endloses Warten zu vermeiden.
• Ungepufferte Kanäle: Verstehen Sie, dass ungepufferte Kanäle sowohl Sender als auch Empfänger benötigen, um fortzufahren. Unsachgemäße Verwendung kann zu Blockaden führen.
• Gepufferte Kanäle: Wählen Sie die Größe des Puffers des Kanals richtig. Ein zu kleiner Puffer kann zu Blockaden führen, wenn Sender und Empfänger nicht synchronisiert sind.
• Verwendung von select: Bei der Arbeit mit mehreren Kanälen verwenden Sie den select-Operator mit einer default-Klausel oder Timeout, um nicht auf einen Kanal zu blockieren.
• Code-Analyse: Verwenden Sie statische Analysen (go vet, staticcheck) und Tools zur Erkennung von Rennbedingungen (go run -race), die auch helfen können, potenzielle gegenseitige Blockaden zu identifizieren.
• Ressourcenhierarchie: Wenn Ressourcen eine Hierarchie haben, erwerben Sie sie von oben nach unten.
• Vermeidung zyklischer Abhängigkeiten: Erstellen Sie keine Situationen, in denen Goroutine A auf eine Ressource wartet, die von B belegt ist, und B auf eine Ressource wartet, die von A belegt ist.

Beispiel für die Verwendung von select mit Timeout:

import (
	"context"
	"time"
)

func beispiel(ch chan int) {
	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
	defer cancel()

	select {
	case wert := <-ch:
		// Wert verarbeiten
		_ = wert
	case <-ctx.Done():
		// Timeout aufgetreten
	}
}