Skip to content
Modul 17 — Asynchrone Programmierung: Async, Await, Futures & Streams
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>
  • None signalisiert Stream-Ende
  • Some(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

0/3

Haken setzen, um deinen Lernfortschritt zu markieren:

  • Rufe dir die Kernpunkte in Erinnerung, bevor du die Liste aufdeckst.

⚠ Häufiger Fehler: buffer_unordered ohne 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

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