sync.Mutex & sync.RWMutex

Teil des Abschnitts Objektorientierte Programmierung der GO-Journey von Coddy. Lektion 63 von 107.

Während Channels der von Go bevorzugte Weg zur Koordination von Goroutinen sind, musst du manchmal gemeinsam genutzte Daten direkt schützen. Das Paket sync stellt Mutexe bereit: Sperren, die sicherstellen, dass jeweils nur eine Goroutine auf eine Ressource zugreift.

Ein sync.Mutex verfügt über zwei Methoden: Lock() und Unlock(). Wenn eine Goroutine Lock() aufruft, erhält sie exklusiven Zugriff. Andere Goroutinen, die Lock() aufrufen, werden blockiert, bis Unlock() aufgerufen wird:

type Counter struct {
    mu    sync.Mutex
    value int
}
func (c *Counter) Increment() {
    c.mu.Lock()
    c.value++
    c.mu.Unlock()
}
func (c *Counter) Value() int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.value
}

Die Verwendung von defer c.mu.Unlock() stellt sicher, dass die Sperre auch dann freigegeben wird, wenn die Funktion vorzeitig zurückkehrt oder eine Panik auslöst: ein gängiges und empfohlenes Muster.

Wenn Lesevorgänge häufig, Schreibvorgänge jedoch selten sind, bietet sync.RWMutex eine bessere Leistung. Es ermöglicht mehreren Lesern den gleichzeitigen Zugriff, während Schreiber exklusiven Zugriff erhalten:

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}
func (c *Cache) Get(key string) string {
    c.mu.RLock()         // mehrere Leser erlaubt
    defer c.mu.RUnlock()
    return c.data[key]
}
func (c *Cache) Set(key, value string) {
    c.mu.Lock()          // exklusiver Zugriff zum Schreiben
    defer c.mu.Unlock()
    c.data[key] = value
}

Verwende RLock()/RUnlock() für Lesevorgänge und Lock()/Unlock() für Schreibvorgänge. Dadurch werden gleichzeitige Lesevorgänge ermöglicht und gleichzeitig sichere Schreibvorgänge gewährleistet.

Aufgabe

Einfach

Bauen wir ein threadsicheres Inventarsystem, das die Lagerbestände von Produkten erfasst. Dein System verarbeitet gleichzeitige Lese- und Schreibvorgänge mithilfe von Mutexen sicher und gewährleistet die Datenintegrität, wenn mehrere Vorgänge gleichzeitig stattfinden.

Du organisierst deinen Code auf zwei Dateien verteilt:

inventory.go: Definiere dein threadsicheres Bestandsverwaltungssystem.
Erstelle eine Inventory-Struktur, die Produktmengen in einer Map speichert und den Zugriff mithilfe eines sync.RWMutex schützt. Dein Inventar soll die folgenden Vorgänge unterstützen:
- NewInventory() *Inventory – Erstellt ein neues Inventar mit einer initialisierten Map
- AddStock(product string, quantity int) – Fügt dem Bestand eines Produkts eine Menge hinzu (verwende eine exklusive Sperre, da dadurch Daten verändert werden)
- GetStock(product string) int – Gibt den aktuellen Bestand eines Produkts zurück oder 0, wenn es nicht gefunden wurde (verwende eine Lesesperre, da hierbei nur Daten gelesen werden)
- RemoveStock(product string, quantity int) bool – Entfernt eine Menge aus dem Bestand, wenn ausreichend Bestand vorhanden ist. Gibt true bei Erfolg und false bei unzureichendem Bestand zurück (verwende eine exklusive Sperre)
Denke daran, zum Entsperren defer zu verwenden, damit die Sperren immer ordnungsgemäß freigegeben werden.
main.go: Lies die Vorgänge ein und demonstriere dein threadsicheres Inventar.
Lies die Anzahl der Vorgänge ein und verarbeite anschließend jeden Vorgang. Jeder Vorgang besitzt einen Typ (add, get oder remove), einen Produktnamen und bei Vorgängen vom Typ add/remove eine Menge.

Gib für jeden Vorgang das Ergebnis aus:
- add: Gib Added [quantity] [product] aus
- get: Gib [product]: [stock] in stock aus
- remove: Gib bei Erfolg Removed [quantity] [product] aus, andernfalls Insufficient stock for [product]

Die folgenden Eingaben werden bereitgestellt:

Zeile 1: Anzahl der Vorgänge (Ganzzahl)
Folgende Zeilen: Für jeden Vorgang:
- Vorgangstyp (add, get oder remove)
- Produktname
- Menge (nur für Vorgänge vom Typ add und remove)

Beispiel: Bei folgender Eingabe:

5
add
apples
50
get
apples
remove
apples
30
remove
apples
25
get
apples

sollte deine Ausgabe wie folgt aussehen:

Added 50 apples
apples: 50 in stock
Removed 30 apples
Insufficient stock for apples
apples: 20 in stock

Der RWMutex ermöglicht es mehreren GetStock-Aufrufen, gleichzeitig zu lesen, während AddStock und RemoveStock beim Ändern des Inventars exklusiven Zugriff erhalten.

Probier es selbst

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Lese die Anzahl der Operationen
	line, _ := reader.ReadString('\n')
	numOps, _ := strconv.Atoi(strings.TrimSpace(line))
	
	// Erstelle ein neues Inventar
	inventory := NewInventory()
	
	// Verarbeite jede Operation
	for i := 0; i < numOps; i++ {
		// Lese den Operationstyp
		opLine, _ := reader.ReadString('\n')
		opType := strings.TrimSpace(opLine)
		
		// Lese den Produktnamen
		productLine, _ := reader.ReadString('\n')
		product := strings.TrimSpace(productLine)
		
		// TODO: Behandle jeden Operationstyp (add, get, remove)
		// Für "add" und "remove" die Menge aus der Eingabe lesen
		// Rufe die entsprechende Inventar-Methode auf
		// Gib das Ergebnis gemäß der Challenge-Beschreibung aus
		
		switch opType {
		case "add":
			// TODO: Menge lesen, Bestand hinzufügen, Ergebnis ausgeben
			
		case "get":
			// TODO: Bestand holen, Ergebnis ausgeben
			
		case "remove":
			// TODO: Menge lesen, Bestand entfernen, entsprechendes Ergebnis ausgeben
			
		}
	}
}