Fortschritt0/7 Lektionen
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
.awaitverwenden, 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
.awaitContext 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
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