Skip to content
Modul 17 — Asynchrone Programmierung: Async, Await, Futures & Streams
5

Concurrency mit Async: Multiple Tasks gleichzeitig

Lektion 5 von 7

Viele Futures gleichzeitig ausführen

tokio::join! Makro

Führt mehrere Futures gleichzeitig aus und wartet auf alle:

#[tokio::main]
async fn main() {
    let (result1, result2, result3) = tokio::join! {
        fetch_data("url1"),
        fetch_data("url2"),
        fetch_data("url3"),
    };
    
    println!("Ergebnisse: {}, {}, {}", result1, result2, result3);
}

futures::future::join_all

Für dynamische Listen von Futures:

use futures::future;

#[tokio::main]
async fn main() {
    let urls = vec!["url1", "url2", "url3"];
    let futures: Vec<_> = urls.into_iter()
        .map(|url| fetch_data(url))
        .collect();
    
    let results = future::join_all(futures).await;
    
    for result in results {
        println!("Got: {}", result);
    }
}

Task Priorisierung

select! - Erstes Futures, das fertig ist

use tokio::sync::oneshot;

#[tokio::main]
async fn main() {
    let (tx1, rx1) = oneshot::channel();
    let (tx2, rx2) = oneshot::channel();
    
    tokio::spawn(async {
        tokio::time::sleep(Duration::from_secs(1)).await;
        tx1.send("Slow").unwrap();
    });
    
    tokio::spawn(async {
        tokio::time::sleep(Duration::from_millis(100)).await;
        tx2.send("Fast").unwrap();
    });
    
    tokio::select! {
        result = rx1 => {
            println!("rx1 finished first: {:?}", result);
        }
        result = rx2 => {
            println!("rx2 finished first: {:?}", result);
        }
    }
}

Kooperatives vs Präemptives Scheduling

Tokio verwendet kooperatives Scheduling:

  • Tasks müssen .await verwenden, damit andere Tasks laufen können
  • Keine präemptives Unterbrechen → keine unvorhersehbaren Pausen
  • Verantwortung beim Entwickler: Tasks nicht zu lange blockieren

Verglichen mit OS-Threads:

  • OS-Threads: präemptiv, Context Switches jederzeit möglich
  • Tokio Tasks: kooperativ, nur bei .await Context Switch

Work Stealing

Tokio verwendet Work Stealing für Lastbalancierung:

  • Jeder Worker-Thread hat eine lokale Task-Queue
  • Wenn ein Thread leer ist, "stiehlt" er Tasks von anderen Queues
  • Reduziert Contention und verbessert Cache-Lokalität

Übung: Parallel fetchen mit join!

🧩 Übung m17-l5-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: tokio::select! mit Futures zu verwenden, die nie fertig werden — dies führt zu einem Deadlock, da das select! auf eines der Futures wartet und die anderen nie beendet werden.

Erinnerungstraining

Tippe den fehlenden Begriff aus dem Gedächtnis ein und prüfe.

Das Makro tokio::! führt mehrere Futures gleichzeitig aus und wartet, bis alle fertig sind.
tokio::! wartet auf das erste Future, das fertig ist — ideal, wenn z. B. ein Timeout gegen eine Operation rennt.
Tokio balanciert Last per : Ein leerer Worker-Thread stiehlt Tasks aus den lokalen Queues anderer Worker.
0 von 3 richtig

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