0Pricing
Learn Rust Coding · Lektion

Einführung in Async/Await

Lernen Sie die Grundlagen von `async`-Funktionen und `await`-Ausdrücken zum Schreiben asynchronen, nicht blockierenden Codes.

Einführung in Async/Await ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Warum asynchrone Programmierung?

Beim Programmieren müssen Aufgaben häufig warten. Beispielsweise muss eine Datei geladen, eine Netzwerkanfrage abgeschlossen oder eine Datenbankabfrage beantwortet werden.

Traditionell blockieren Programme während dieser Wartezeiten. Das bedeutet, dass sie alle anderen Vorgänge anhalten, bis die Aufgabe abgeschlossen ist. Dadurch können Anwendungen langsam und nicht mehr reaktionsfähig werden.

Wenn Code wartet ...

Betrachten Sie dieses einfache Beispiel für einen blockierenden Vorgang. Das Programm wartet 2 Sekunden, bevor es die zweite Nachricht ausgibt.

Führen Sie es aus:

use std::thread;
use std::time::Duration;

fn main() {
  println!("Starting a blocking task...");
  thread::sleep(Duration::from_secs(2)); // This blocks!
  println!("Blocking task finished!");
}

Die Kosten des Wartens

Im vorherigen Beispiel hat das gesamte Programm gewartet. Bei einem Webserver würde das bedeuten: Während die Anfrage eines Benutzers auf die Datenbank wartet, könnten keine anderen Benutzer bedient werden.

Asynchrone Programmierung ermöglicht es Ihrem Programm, eine lang laufende Aufgabe zu starten und anschließend andere Arbeiten auszuführen, anstatt zu warten. Sobald die lange Aufgabe bereit ist, kann das Programm sie wieder aufnehmen.

Der asynchrone Ansatz von Rust

Rust stellt leistungsfähige Sprachfunktionen für asynchrone Programmierung bereit: die Schlüsselwörter async und await.

  • async-Funktionen sind spezielle Funktionen, die angehalten und fortgesetzt werden können.
  • .await wird innerhalb einer async-Funktion verwendet, um auf den Abschluss einer anderen asynchronen Aufgabe zu warten, ohne das gesamte Programm zu blockieren.

`async`-Funktionen definieren

Sie deklarieren eine asynchrone Funktion, indem Sie das Schlüsselwort async vor fn setzen. Eine async-Funktion gibt immer ein Future zurück.

Ein Future ist ein Wert, der möglicherweise noch nicht bereit ist. Er steht für eine Berechnung, die letztendlich ein Ergebnis liefert.

async fn my_async_task() -> u32 {
  // This task will eventually return 42
  42
}

Mit `.await` pausieren

Das Schlüsselwort .await sorgt dafür, dass asynchrone Programmierung nicht blockierend ist. Wenn Sie auf ein Future mit .await warten, führt Ihre async-Funktion Folgendes aus:

  • Sie pausiert ihre eigene Ausführung.
  • Sie ermöglicht dem Programm, andere Arbeiten auszuführen.
  • Sie wird fortgesetzt, sobald das erwartete Future bereit ist.

Das ist vergleichbar mit dem Drücken einer Pausentaste für die aktuelle Aufgabe, während eine andere Aufgabe abgeschlossen wird.

Asynchronen Code ausführen: Executors

Eine async-Funktion gibt ein Future zurück, führt den darin enthaltenen Code jedoch nicht sofort aus. Futures sind lazy.

Um eine async-Funktion tatsächlich auszuführen und ihr Future zu verarbeiten, benötigen Sie einen Executor. Für einfache Beispiele können wir futures::executor::block_on verwenden. Diese Funktion führt ein Future im aktuellen Thread bis zum Abschluss aus.

Ihr erstes `async`/`await`-Programm

So arbeiten async, await und ein einfacher Executor zusammen. Beachten Sie, dass block_on in main verwendet wird, um den asynchronen Ablauf zu starten.

Dieses Beispiel simuliert eine asynchrone Verzögerung, ohne den Thread der main-Funktion zu blockieren (konzeptionell; block_on selbst blockiert, bis das Future abgeschlossen ist, aber die asynchrone Aufgabe gibt dabei die Ausführung ab).

use futures::executor::block_on;
use std::time::Duration;

async fn learn_and_wait() {
  println!("Learning asynchronously...");
  // Simulate an async operation that takes time
  // In a real app, this would be an I/O op
  tokio::time::sleep(Duration::from_secs(1)).await;
  println!("Finished learning!");
}

fn main() {
  println!("Starting main function.");
  block_on(learn_and_wait());
  println!("Main function finished.");
}

Das `Future`-Trait verstehen

Wenn Sie async fn my_func() schreiben, wandelt Rust dies tatsächlich in eine Zustandsmaschine um, die das Future-Trait implementiert.

Das Future-Trait verfügt über eine zentrale Methode namens poll. Ein Executor ruft sie wiederholt auf, um zu prüfen, ob die Aufgabe Fortschritte machen kann. Wenn ein Future mit .await erwartet wird, weist es den Executor an, ein anderes Future so lange abzufragen, bis es abgeschlossen ist.

Kurztest: Grundlagen von Async/Await

Sie haben die Grundlagen von async und await kennengelernt. Finden wir heraus, ob Sie die wichtigsten Aufgaben dieser Elemente erkennen können.

Rückblick und nächste Schritte

Großartige Arbeit! Sie haben Ihre ersten Schritte in der asynchronen Rust-Programmierung gemacht.

  • Wir haben gesehen, dass synchroner Code Programmabläufe blockiert und Programme warten lässt.
  • Asynchroner Code ermöglicht die nebenläufige Ausführung von Aufgaben, ohne sie zu blockieren.
  • Das Schlüsselwort async deklariert eine asynchrone Funktion, die ein Future zurückgibt.
  • Das Schlüsselwort .await pausiert eine async-Funktion, bis ein Future bereit ist.
  • Ein Executor (z. B. block_on) wird benötigt, um Futures auszuführen.

Als Nächstes sehen wir uns Tokio an, eine leistungsstarke Runtime und ein Ökosystem zum Entwickeln asynchroner Anwendungen in Rust!

Häufig gestellte Fragen

Ist die Lektion „Einführung in Async/Await“ kostenlos?

Ja — der vollständige Text von „Einführung in Async/Await“ 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 „Einführung in Async/Await“?

Lernen Sie die Grundlagen von `async`-Funktionen und `await`-Ausdrücken zum Schreiben asynchronen, nicht blockierenden Codes. 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 1 von 3.

Wie lange dauert die Lektion „Einführung in Async/Await“?

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