Welche Arten von Mutexes bietet die Standardbibliothek von Go?

Die Standardbibliothek von Go stellt zwei Haupttypen von Mutexen im Paket sync bereit:

• sync.Mutex: Ein grundlegender Mutex, der gegenseitigen Ausschluss gewährleistet. Er kann in zwei Zuständen sein: gesperrt oder entsperrt. Nur eine Goroutine kann den Mutex zu einem Zeitpunkt halten.
• sync.RWMutex: Ein Mutex für Lesen/Schreiben. Er erlaubt mehreren Goroutines gleichzeitig das Lesen (durch RLock), aber nur einer Goroutine das Schreiben (durch Lock). Das Schreiben blockiert alle Operationen (Lesen und Schreiben).

Hauptmethoden von sync.Mutex:

Methode	Beschreibung
Lock()	Sperrt den Mutex. Wenn er bereits gesperrt ist, wird die aufrufende Goroutine blockiert, bis er freigegeben wird.
Unlock()	Entsperrt den Mutex. Es entsteht ein Panic, wenn der Mutex nicht von der aufrufenden Goroutine gesperrt war.

Hauptmethoden von sync.RWMutex:

Methode	Beschreibung
Lock()	Sperrt den Mutex für Schreibzugriffe. Sperrt alle Lese- und Schreiboperationen.
Unlock()	Entsperrt den Mutex für Schreibzugriffe. Es entsteht ein Panic, wenn der Mutex nicht für Schreiben gesperrt war.
RLock()	Sperrt den Mutex für Lesezugriffe. Sperrt keine anderen Leseoperationen. Wird blockiert, wenn eine Schreibsperre besteht.
RUnlock()	Entsperrt den Mutex für Lesezugriffe. Es entsteht ein Panic, wenn der Mutex nicht für Lesen gesperrt war.
RLocker()	Gibt einen Locker zurück, der RLock und RUnlock verwendet.

Beispiel für die Verwendung von sync.Mutex:

package main

import (
	"fmt"
	"sync"
	"time"
)

var counter int
var mutex sync.Mutex

func increment() {
	mutex.Lock() // Sperrt den Mutex
	counter++
	fmt.Printf("Counter: %d\n", counter)
	mutex.Unlock() // Entsperrt den Mutex
}

func main() {
	for i := 0; i < 10; i++ {
		go increment()
	}
	time.Sleep(time.Second) // Gibt den Goroutines Zeit zum Beenden
}

Beispiel für die Verwendung von sync.RWMutex:

package main

import (
	"fmt"
	"sync"
	"time"
)

var data string
var rwMutex sync.RWMutex

func readData() {
	rwMutex.RLock() // Sperrt für Lesen
	fmt.Printf("Daten lesen: %s\n", data)
	rwMutex.RUnlock() // Entsperrt für Lesen
}

func writeData(newData string) {
	rwMutex.Lock() // Sperrt für Schreiben
	data = newData
	fmt.Printf("Daten schreiben: %s\n", data)
	rwMutex.Unlock() // Entsperrt für Schreiben
}

func main() {
	go writeData("Hallo")
	time.Sleep(100 * time.Millisecond) // Gibt Zeit für das Schreiben

	for i := 0; i < 5; i++ {
		go readData() // Mehrere gleichzeitige Lesezugriffe sind erlaubt
	}

	time.Sleep(time.Second) // Gibt Zeit für die Goroutines
	go writeData("Welt")
	time.Sleep(100 * time.Millisecond)
	go readData()

	time.Sleep(time.Second)
}