Skip to content
Modul 17 — Asynchrone Programmierung: Async, Await, Futures & Streams
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 Schreiboperationen
  • Arc<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

0/3

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::Mutex statt tokio::sync::Mutex in 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

This site uses essential cookies for Stripe payments. No tracking cookies.