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

Executors: Futures ausführen

Lektion 4 von 7

Futures tun nichts, bis ein Executor sie pollt und vorantreibt.

Beliebte executors

Tokio (empfohlen)

Der De-facto-Standard für async Rust:

#[tokio::main]
async fn main() {
    let result = my_async_function().await;
    println!("{}", result);
}

Das #[tokio::main] Makro:

  • Erstellt einen Tokio-Runtime
  • Führt den async main-Body aus
  • Blockiert den main-Thread, bis alle Tasks fertig sind

Async-std

Alternative Runtime:

#[async_std::main]
async fn main() {
    let result = my_async_function().await;
    println!("{}", result);
}

Manuelles Polling (selten nötig)

use futures::executor::block_on;

fn main() {
    let future = async {
        println!("Running...");
        42
    };
    
    let result = block_on(future);
    println!("Result: {}", result);
}

Warnung: block_on blockiert den aktuellen Thread! Nur für Tests und einfa

Runtime Selection

Wähle dein Runtime basierend auf deinen Anforderungen:

  • Tokio: Volle Features, hohe Performance, am weitesten verbreitet
  • async-std: Einfacher, basiert auf libstd, weniger Abhängigkeiten
  • Custom Runtime: Für spezielle Anforderungen (z. B. embedded)

Tokio Features

Tasks spawning

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        // Läuft auf einem Worker-Thread
        "Hello from Tokio"
    });
    
    let result = handle.await.unwrap();
    println!("{}", result);
}

Timeouts

use std::time::Duration;

#[tokio::main]
async fn main() {
    let result = tokio::time::timeout(
        Duration::from_secs(5),
        long_operation()
    ).await;
    
    match result {
        Ok(value) => println!("Fertig: {}", value),
        Err(_) => println!("Timeout!"),
    }
}

Übung: Tokio Task spawning

🧩 Übung m17-l4-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::spawn ohne #[tokio::main] oder eine laufende Runtime zu verwenden — dies führt zu einem Panic, da kein Executor existiert, der die Tasks ausführen kann.

Erinnerungstraining

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

Das Makro erstellt die Tokio-Runtime und führt den async main-Body aus — der De-facto-Standard-Executor für async Rust.
startet einen Task im Hintergrund auf einem Worker-Thread und liefert ein JoinHandle, auf dem du .await aufrufst.
tokio::time::(Duration::from_secs(5), long_operation()) bricht eine Operation nach Ablauf der Frist ab.
0 von 3 richtig

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