Fortschritt0/7 Lektionen
6
Streams: Asynchrone Sequenzen
Lektion 6 von 7
Ein Stream ist ein Future, das mehrere Werte über die Zeit liefert.
Das Stream Trait
pub trait Stream {
type Item;
fn poll_next(
self: Pin<&mut Self>,
cx: &mut Context<'_>
) -> Poll<Option<Self::Item>>;
}
- Ähnlich wie Future, aber liefert
Option<Item> Nonesignalisiert Stream-EndeSome(item)liefert den nächsten Wert
Streams erstellen
Aus einer Collection
use futures::stream::{self, StreamExt};
#[tokio::main]
async fn main() {
let stream = stream::iter(vec![1, 2, 3, 4, 5]);
let sum = stream
.filter(|x| *x % 2 == 0) // Nur gerade Zahlen
.fold(0, |acc, x| acc + x)
.await;
println!("Summe der geraden Zahlen: {}", sum);
}
Asynchrone Generierung
async fn generate_numbers() -> impl Stream<Item = i32> {
futures::stream::iter(0..10)
.map(|i| async move {
tokio::time::sleep(Duration::from_millis(100)).await;
i * 2
})
.buffer_unordered(5) // Maximal 5 Futures gleichzeitig
}
Streams verarbeiten
for await Loop
#[tokio::main]
async fn main() {
let mut stream = generate_data();
while let Some(item) = stream.next().await {
println!("Received: {}", item);
}
}
Streams kombinieren
use futures::stream;
#[tokio::main]
async fn main() {
let stream1 = stream::iter(1..=3);
let stream2 = stream::iter(4..=6);
// Zwei Streams zusammenführen (abwechselnd)
let merged = stream::select(stream1, stream2);
// Oder: zuerst stream1, dann stream2
let chained = stream1.chain(stream2);
}
Backpressure
Streams können Backpressure automatisch handhaben:
- Wenn der Consumer langsamer ist als der Producer
- Der Producer wird automatisch verlangsamt
- Verhindert Speicherüberlauf
// Ohne Backpressure: Producer könnte Consumer überfluten
let stream = stream::iter(0..1000000);
// Mit Backpressure: Producer wartet auf Consumer
let processed = stream
.map(|x| async move { /* langsame Verarbeitung */ x * 2 })
.buffer_unordered(100); // Maximal 100 in Flight
Übung: Stream Processing
🧩 Übung m17-l6-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:
buffer_unorderedohne Limit zu verwenden — dies kann bei vielen parallelen Futures zu Speicherüberlauf führen, da alle Futures gleichzeitig gestartet werden und auf ihr Ergebnis warten.
Erinnerungstraining
Tippe den fehlenden Begriff aus dem Gedächtnis ein und prüfe.
poll_next() eines Streams liefert Poll<Option<Item>>: Some(item) ist der nächste Wert — und signalisiert das Stream-Ende.
Verarbeitet wird ein Stream mit while let Some(item) = stream.().await { ... } — die Methode kommt aus dem StreamExt-Trait.
(5) begrenzt bei Streams, wie viele Futures maximal gleichzeitig in flight sind — das erzeugt Backpressure.
0 von 3 richtig