0Pricing
Learn Rust Coding · Lektion

Asynchrone Anwendungen mit Tokio entwickeln

Verwenden Sie die Tokio-Laufzeitumgebung, um asynchrone Aufgaben effizient auszuführen und I/O sowie andere nebenläufige Vorgänge zu verarbeiten.

Asynchrone Anwendungen mit Tokio entwickeln ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Die Tokio-Runtime kennenlernen

Willkommen zurück! In der vorherigen Lektion haben Sie async und await kennengelernt. Aber wie wird eine async-Funktion eigentlich ausgeführt?

Hier kommt eine asynchrone Runtime wie Tokio ins Spiel. Tokio ist eine leistungsstarke Bibliothek, die die Ausführungsumgebung für Ihren asynchronen Rust-Code bereitstellt.

  • Sie plant Futures und führt sie aus.
  • Sie verarbeitet nicht blockierende E/A-Operationen.
  • Sie verwaltet nebenläufige Aufgaben effizient.

Asynchronen Code ausführen

Für den Einstieg in Tokio verwenden Sie normalerweise das Attributmakro #[tokio::main]. Dieses Makro wandelt Ihre async fn main() in eine standardmäßige fn main() um, die die Tokio-Runtime initialisiert und Ihren asynchronen Code ausführt.

Betrachten Sie es als Einstiegspunkt Ihrer asynchronen Anwendung.

use tokio;

#[tokio::main]
async fn main() {
  println!("Hello from Tokio!");
}

Neue asynchrone Aufgaben starten

Eine der wichtigsten Funktionen von Tokio ist die Möglichkeit, mehrere asynchrone Vorgänge nebenläufig auszuführen. Dafür können Sie tokio::spawn verwenden.

tokio::spawn nimmt ein Future entgegen und plant es zur Ausführung auf der Tokio-Runtime ein. Dadurch kann Ihre Hauptaufgabe weiter ausgeführt werden, während die gestartete Aufgabe im Hintergrund läuft.

  • Der Vorgang ist nicht blockierend.
  • Es wird ein JoinHandle zurückgegeben, auf dessen Abschluss Sie warten können.
  • Aufgaben werden unabhängig voneinander ausgeführt.

<code>tokio::spawn</code> in Aktion

Sehen wir uns an, wie tokio::spawn die nebenläufige Ausführung von Code ermöglicht. Beachten Sie, dass beide Nachrichten angezeigt werden. Aufgrund der Wartezeit kann die Nachricht „done“ jedoch vor der Nachricht „task complete“ ausgegeben werden.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  // Spawn a new task
  let handle = tokio::spawn(async {
    sleep(Duration::from_secs(1)).await;
    println!("Async task complete!");
  });

  println!("Main task continuing...");

  // Wait for the spawned task to finish
  handle.await.unwrap();
  println!("All tasks done.");
}

Auf mehrere Aufgaben warten

Wenn Sie mehrere Aufgaben haben, müssen Sie häufig warten, bis alle abgeschlossen sind. Tokio stellt dafür das Makro tokio::join! bereit.

tokio::join! ermöglicht es, gleichzeitig auf mehrere Futures zu warten und ihre Ergebnisse zusammenzuführen. Es ähnelt dem Warten mit `await` auf mehrere JoinHandles, ist für eine feste Menge von Futures jedoch häufig kürzer.

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  let task1 = async {
    sleep(Duration::from_secs(1)).await;
    println!("Task 1 finished");
    1
  };

  let task2 = async {
    sleep(Duration::from_millis(500)).await;
    println!("Task 2 finished");
    2
  };

  let (result1, result2) = tokio::join!(task1, task2);
  println!("Results: {}, {}", result1, result2);
}

Asynchrone Datei-E/A mit Tokio

Herkömmliche Dateioperationen können den Thread blockieren, was für asynchrone Anwendungen problematisch ist. Tokios Modul tokio::fs stellt asynchrone Varianten von Dateisystemoperationen bereit.

Dadurch bleibt Ihre Anwendung auch beim Lesen großer Dateien oder bei vielen Dateioperationen reaktionsfähig, da die E/A nicht blockierend verarbeitet wird.

  • tokio::fs::read_to_string
  • tokio::fs::write
  • tokio::fs::File für mehr Kontrolle

Eine Datei asynchron lesen

So können Sie mit tokio::fs::read_to_string eine Datei asynchron lesen. Damit dieser Code ausgeführt werden kann, muss sich im selben Verzeichnis wie Ihr Rust-Projekt eine Datei namens hello.txt mit Inhalt befinden (z. B. in src/ oder im Projektstammverzeichnis).

use tokio::fs;

#[tokio::main]
async fn main() {
  let path = "hello.txt";
  // Create a dummy file for the example if it doesn't exist
  // In a real app, you'd handle file creation/existence more robustly
  if let Err(_) = fs::metadata(path).await {
    fs::write(path, "Hello, Tokio file!").await.unwrap();
  }

  match fs::read_to_string(path).await {
    Ok(content) => println!("File content: '{}'", content),
    Err(e) => eprintln!("Error reading file: {}", e),
  }
}

Asynchrone Netzwerkoperationen

Tokio spielt seine Stärken besonders in der Netzwerkprogrammierung aus. Sein Modul tokio::net bietet nicht blockierende Primitive für die TCP- und UDP-Kommunikation.

Das ist entscheidend für die Entwicklung leistungsfähiger Server oder Clients, die viele Verbindungen gleichzeitig verarbeiten können, ohne für jede Verbindung einen eigenen Thread zu benötigen.

  • tokio::net::TcpListener für Server
  • tokio::net::TcpStream für Clientverbindungen

Grundstruktur eines asynchronen TCP-Servers

Auch wenn ein vollständiger Server komplex ist, zeigt dieses Beispiel die zentrale Schleife eines asynchronen TCP-Servers mit Tokio. Sie wartet auf eingehende Verbindungen und gibt für jede eine Nachricht aus. Führen Sie den Code aus und öffnen Sie anschließend Ihren Browser unter http://127.0.0.1:8080, um Verbindungen zu sehen.

use tokio::net::TcpListener;

#[tokio::main]
async fn main() {
  let listener = TcpListener::bind("127.0.0.1:8080").await.unwrap();
  println!("Listening on: {}", listener.local_addr().unwrap());

  loop {
    let (socket, addr) = listener.accept().await.unwrap();
    println!("Accepted connection from: {}", addr);
    // In a real server, you'd spawn a task to handle the socket
    // tokio::spawn(async move { handle_connection(socket).await; });
  }
}

// fn handle_connection(socket: TcpStream) { /* ... */ } // Placeholder

Tokio-Aufgaben: Herausforderung

Betrachten Sie den folgenden Rust-Code, der Tokio verwendet. Welche Nachricht wird bei der Ausführung dieses Programms *zuerst* in der Konsole ausgegeben?

use tokio::time::{sleep, Duration};

#[tokio::main]
async fn main() {
  tokio::spawn(async {
    sleep(Duration::from_millis(200)).await;
    println!("Task 1: Done");
  });

  tokio::spawn(async {
    sleep(Duration::from_millis(100)).await;
    println!("Task 2: Done");
  });

  println!("Main: Starting tasks...");

  sleep(Duration::from_millis(300)).await;
  println!("Main: Finishing.");
}

Rückblick: Mit Tokio entwickeln

Sie haben einen wichtigen Schritt beim Entwickeln asynchroner Anwendungen mit Rust und Tokio gemacht!

  • Tokio fungiert als asynchrone Runtime und führt Ihren async-Code aus.
  • #[tokio::main] ist der asynchrone Einstiegspunkt Ihres Programms.
  • Mit tokio::spawn können Sie mehrere Aufgaben nebenläufig ausführen.
  • tokio::join! hilft dabei, auf mehrere Futures zu warten.
  • Tokio stellt nicht blockierende E/A für Dateien (tokio::fs) und Netzwerke (tokio::net) bereit.

Diese Werkzeuge sind grundlegend für die Entwicklung hochgradig nebenläufiger und reaktionsfähiger Anwendungen in Rust. Üben Sie weiter!

Häufig gestellte Fragen

Ist die Lektion „Asynchrone Anwendungen mit Tokio entwickeln“ kostenlos?

Ja — der vollständige Text von „Asynchrone Anwendungen mit Tokio entwickeln“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Asynchrone Anwendungen mit Tokio entwickeln“?

Verwenden Sie die Tokio-Laufzeitumgebung, um asynchrone Aufgaben effizient auszuführen und I/O sowie andere nebenläufige Vorgänge zu verarbeiten. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „Asynchrone Anwendungen mit Tokio entwickeln“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Einführung in Async/Await
  2. Asynchrone Anwendungen mit Tokio entwickeln
  3. Mit Futures und Tasks arbeiten
← Zurück zu Learn Rust Coding