Fortschritt0/7 Lektionen
7
Shared State: Mutex und RwLock in Async
Lektion 7 von 7
Das Problem: Shared Mutable State in Async
In synchronem Code:
let mut data = vec![1, 2, 3];
// ... kann einfach mutieren
In async Code: Daten könnten von mehreren Tasks gleichzeitig zugreifen → Data Race
Tokio's Async Mutex
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
let shared_data = Mutex::new(Vec::new());
let handle1 = tokio::spawn(async move {
let mut guard = shared_data.lock().await;
guard.push(1);
});
let handle2 = tokio::spawn(async move {
let mut guard = shared_data.lock().await;
guard.push(2);
});
handle1.await.unwrap();
handle2.await.unwrap();
let data = shared_data.lock().await;
println!("Data: {:?}", *data); // [1, 2] oder [2, 1]
// → [1, 2] oder [2, 1] je nach Scheduling-Reihenfolge
}
Mutex::lock()ist async — gibt Thread frei während des Wartens- Kein Deadlock möglich (Tokio erkennt es)
RwLock: Mehrere Reader, ein Writer
use tokio::sync::RwLock;
#[tokio::main]
async fn main() {
let data = RwLock::new(42);
// Mehrere Reader gleichzeitig
let handle1 = tokio::spawn(async move {
let guard = data.read().await;
println!("Reader 1: {}", *guard);
});
let handle2 = tokio::spawn(async move {
let guard = data.read().await;
println!("Reader 2: {}", *guard);
});
// Exklusiver Writer
let handle3 = tokio::spawn(async move {
let mut guard = data.write().await;
*guard = 100;
});
handle1.await.unwrap();
handle2.await.unwrap();
handle3.await.unwrap();
}
Arc in Async Kontext
use std::sync::Arc;
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
// Arc für gemeinsamen Besitz
let shared = Arc::new(Mutex::new(0));
let shared_clone = Arc::clone(&shared);
let handle = tokio::spawn(async move {
let mut guard = shared_clone.lock().await;
*guard += 1;
});
handle.await.unwrap();
let guard = shared.lock().await;
println!("Count: {}", *guard);
}
Arc + Mutex vs Arc + RwLock
Arc<Mutex<T>>: Exklusiver Zugriff, gut für häufige SchreiboperationenArc<RwLock<T>>: Mehrere Leser, ein Schreiber, gut für lese-intensive Workloads
Beide sind async-aware in Tokio.
Übung: Thread-safe Counter mit Mutex
🧩 Übung m17-l7-e1
🔮 Vorhersage: Was passiert beim Ausführen?
Editor wird geladen…
KI-Tutor (sokratisch — keine Komplettlösungen)
✅ Wichtige Erkenntnisse
Haken setzen, um deinen Lernfortschritt zu markieren:
Rufe dir die Kernpunkte in Erinnerung, bevor du die Liste aufdeckst.
⚠ Häufiger Fehler: Den Standard-
std::sync::Mutexstatttokio::sync::Mutexin async Code zu verwenden — der synchronisierte Mutex blockiert den Thread beim Warten, was die gesamte async Runtime blockiert.
Erinnerungstraining
Tippe den fehlenden Begriff aus dem Gedächtnis ein und prüfe.
Bei tokio::sync::Mutex ist () async: Der Thread wird freigegeben, solange auf die Sperre gewartet wird.
Ein tokio::sync:: erlaubt mehrere Reader gleichzeitig — aber nur einen exklusiven Writer; ideal für lese-intensive Workloads.
Geteilten Besitz über Tasks hinweg gibt ::new(Mutex::new(0)) — jede Task bekommt ihre Referenz per ::clone().
0 von 3 richtig