Rust Async-Programmierung async/await

In der modernen Programmierung wird asynchrone Programmierung immer wichtiger, weil sie es Programmen ermöglicht, während des Wartens auf I/O-Operationen (wie Datei-Lese-/Schreibvorgänge, Netzwerkkommunikation usw.) nicht blockiert zu werden, wodurch Leistung und Reaktionsfähigkeit verbessert werden.

Asynchrone Programmierung ist eine Möglichkeit, nicht blockierende Operationen in Rust zu handhaben, wodurch Programme nicht blockiert werden, während sie lang laufende I/O-Operationen ausführen, sondern stattdessen während des Wartens andere Aufgaben ausführen können.

Rust bietet eine Vielzahl von Tools und Bibliotheken für asynchrone Programmierung, darunterasyncundawaitSchlüsselwörter,Futuresund asynchrone Laufzeitumgebungen (wie tokio, async-std usw.) sowie weitere Hilfswerkzeuge.

  • Future: Future ist eine Abstraktion in Rust, die eine asynchrone Operation repräsentiert. Es ist eine Berechnung, die noch nicht abgeschlossen sein muss und zu einem späteren Zeitpunkt einen Wert oder einen Fehler zurückgeben wird.

  • async/await:asyncDas Schlüsselwort wird verwendet, um eine asynchrone Funktion zu definieren, die ein Future zurückgibt.awaitDas Schlüsselwort wird verwendet, um die Ausführung des aktuellen Future anzuhalten, bis es abgeschlossen ist.

Beispiel

Das folgende Beispiel zeigt, wie man die Schlüsselwörter async und await verwendet, um eine asynchrone Funktion zu schreiben, und wie man eine asynchrone Aufgabe in einer asynchronen Funktion ausführt und auf ihre Fertigstellung wartet.

Beispiel

// Erforderliche Abhängigkeiten importieren
use tokio;
use tokio::time::{self, Duration};

// Asynchrone Funktion, die eine asynchrone Aufgabe simuliert
async fn async_task() -> u32 {
    // Simuliere eine asynchrone Operation, warte 1 Sekunde
    time::sleep(Duration::from_secs(1)).await;
    // Das Ergebnis zurückgeben
    42
}

// Funktion zur Ausführung asynchroner Aufgaben
async fn execute_async_task() {
    // Asynchrone Aufgabe aufrufen und warten, bis sie abgeschlossen ist
    let result = async_task().await;
    // Das Ergebnis ausgeben
    println!("Ergebnis der asynchronen Aufgabe: {}", result);
}

// Hauptfunktion
#[tokio::main]
async fn main() {
    println!("Starte mit der Ausführung der asynchronen Aufgabe...");
    // Funktion zur Ausführung asynchroner Aufgaben aufrufen und auf deren Abschluss warten
    execute_async_task().await;
    println!("Asynchrone Aufgabe abgeschlossen!");
}

Im obigen Code haben wir zuerst eine async-Funktion definiertasync_task(), die eine asynchrone Operation simuliert, mit dertokio::time::delay_for()Methode, um 1 Sekunde zu warten, und gibt dann das Ergebnis 42 zurück. Dann haben wir eine async-Task-Ausführungsfunktion definiertexecute_async_task(), in der wir die async-Funktion aufgerufen und dasawaitSchlüsselwort verwendet haben, um auf den Abschluss der async-Aufgabe zu warten. Schließlich in dermainFunktion verwenden wir dastokio::mainMakro, um die async-Task-Ausführungsfunktion auszuführen und auf ihren Abschluss zu warten.

Wenn Sie dieses Programm ausführen, können Sie sehen, dass das Programm eine Meldung ausgibt, die anzeigt, dass es mit der Ausführung der async-Aufgabe begonnen hat, dann nach 1 Sekunde Warten das Ergebnis der async-Aufgabe ausgibt und schließlich eine Meldung ausgibt, die anzeigt, dass die async-Aufgabe abgeschlossen wurde:

Start executing async task...
Async task result: 42
Async task completed!

Dieses Beispiel demonstriert die Verwendung vonasyncundawaitSchlüsselwörtern, um async-Funktionen zu schreiben, und wie man async-Aufgaben in async-Funktionen ausführt und auf ihren Abschluss wartet.

Das folgende Beispiel verwendet die tokio-Bibliothek, um eine asynchrone HTTP-Anfrage auszuführen, und gibt die Antwort aus:

Beispiel 2

// Erforderliche Abhängigkeiten importieren
use std::error::Error;
use tokio::runtime::Runtime;
use reqwest::get;

// Asynchrone Funktion zum Ausführen einer HTTP-GET-Anfrage und Zurückgeben der Antwort
async fn fetch_url(url: &str) -> Result<String, Box<dyn Error>> {
    // Verwende reqwest, um eine asynchrone HTTP-GET-Anfrage durchzuführen
    let response = get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

// Funktion zur Ausführung asynchroner Aufgaben
async fn execute_async_task() -> Result<(), Box<dyn Error>> {
    // Eine asynchrone HTTP-Anfrage ausführen
    let url = "https://jsonplaceholder.typicode.com/posts/1";
    let result = fetch_url(url).await?;
    // Die Antwort ausgeben
    println!("Antwort: {}", result);
    OK(())
}

// Hauptfunktion
fn main() {
    // Eine asynchrone Laufzeitumgebung erstellen
    let rt = Runtime::new().unwrap();
    // Die asynchrone Aufgabe in der asynchronen Laufzeitumgebung ausführen
    let result = rt.block_on(execute_async_task());
    // Das Ausführungsergebnis der asynchronen Aufgabe behandeln
    match result {
        Ok(_) => println!("Async task executed successfully!"),
        Err(e) => eprintln!("Error: {}", e),
    }
}

Im obigen Code haben wir zunächst die Bibliotheken tokio und reqwest importiert, die jeweils zum Ausführen asynchroner Aufgaben und zum Stellen von HTTP-Anfragen verwendet werden. Dann haben wir eine asynchrone Funktion fetch_url definiert, die verwendet wird, um eine asynchrone HTTP-GET-Anfrage durchzuführen und die Antwort zurückzugeben.

Als Nächstes haben wir eine Funktion zur Ausführung asynchroner Aufgaben execute_async_task definiert, die eine asynchrone HTTP-Anfrage stellt und die Antwort ausgibt.

Schließlich haben wir in der main-Funktion eine asynchrone tokio-Laufzeitumgebung erstellt, darin die asynchrone Aufgabe ausgeführt und das Ausführungsergebnis der asynchronen Aufgabe behandelt.

Wenn Sie dieses Programm ausführen, können Sie sehen, dass die Antwort der asynchronen HTTP-Anfrage ausgegeben wird. Im Beispiel wurden Post-Daten von JSONPlaceholder angefordert und deren Inhalt ausgegeben.


Erklärung der asynchronen Programmierung

async-Schlüsselwort

Das Schlüsselwort async wird verwendet, um asynchrone Funktionen zu definieren, d. h. Funktionen, die einen Future- oder impl-Future-Typ zurückgeben. Wenn eine asynchrone Funktion ausgeführt wird, gibt sie ein unvollendetes Future-Objekt zurück, das eine Berechnung oder Operation darstellt, die noch nicht abgeschlossen ist.

Asynchrone Funktionen können await-Ausdrücke enthalten, die verwendet werden, um zu warten, bis andere asynchrone Operationen abgeschlossen sind.

Beispiel

async fn hello() -> String {
    "Hello, world!".to_string()
}

await-Schlüsselwort

Das await-Schlüsselwort wird verwendet, um auf den Abschluss einer asynchronen Operation zu warten und ihr Ergebnis zu erhalten.

Der await-Ausdruck kann nur in async-Funktionen oder async-Blöcken verwendet werden. Er pausiert die Ausführung der aktuellen async-Funktion, wartet auf den Abschluss des erwarteten Future und setzt dann die Ausführung des nachfolgenden Codes fort.

Beispiel

async fn print_hello() {
    let result = hello().await;
    println!("{}", result);
}

Rückgabewert einer async-Funktion

Der Rückgabetyp einer async-Funktion ist normalerweiseimpl Future<Output = T>, wobeiTist der Ergebnistyp der asynchronen Operation. Da der Rückgabewert einer async-Funktion ein Future ist, können Sie.awaitverwenden, um auf den Abschluss der asynchronen Operation zu warten und ihr Ergebnis zu erhalten.

Beispiel

async fn add(a: i32, b: i32) -> i32 {
    a + b
}

Async-Block

Zusätzlich zum Definieren asynchroner Funktionen bietet Rust auch eine async-Block-Syntax, mit der asynchrone Operationen in synchronem Code verwendet werden können. Ein async-Block besteht ausasync { }, der async-Funktionsaufrufe undawait-Ausdrücke enthalten kann.

Beispiel

async {
    let result1 = hello().await;
    let result2 = add(1, 2).await;
    println!("Result: {}, {}", result1, result2);
};

Asynchrone Task-Ausführung

In Rust müssen async-Tasks normalerweise in einem Ausführungskontext ausgeführt werden. Du kannsttokio::main、async-stdvontask::block_onoderfutures::executor::block_onund andere Funktionen, um async-Tasks auszuführen. Diese Funktionen akzeptieren eine async-Funktion oder einen async-Block und führen sie im aktuellen Thread oder in der aktuellen Ausführungsumgebung aus.

Beispiel

use async_std::task;

fn main() {
    task::block_on(print_hello());
}

Fehlerbehandlung

awaitgefolgt von einem?-Operator kann Fehler weitergeben. WennawaitFuture mit einem Fehler abgeschlossen wird, dann wird dieser Fehler an den Aufrufer weitergegeben.

Beispiel

async fn my_async_function() -> Result<(), MyError> {
    some_async_operation().await?;
    // Wenn some_async_operation fehlschlägt, wird der Fehler weitergegeben
}

Asynchrone Trait-Methoden

Rust ermöglicht das Definieren asynchroner Methoden für Traits. Dadurch können Sie asynchrone Operationen für Objekte unterschiedlicher Typen definieren.

Beispiel

trait MyAsyncTrait {
    async fn async_method(&self) -> Result<(), MyError>;
}

impl MyAsyncTrait for MyType {
    async fn async_method(&self) -> Result<(), MyError> {
        // Asynchrone Logik
    }
}

Asynchroner Kontext

In Rust wird asynchroner Code normalerweise in einer Async-Runtime (wie Tokio oder async-std) ausgeführt. Diese Runtimes bieten Mechanismen zum Planen und Ausführen asynchroner Aufgaben.

Beispiel

#[tokio::main]
async fn main() {
    some_async_operation().await;
}

Im obigen Code,#[tokio::main]Das Attribut-Makro verpacktmain, die Funktion, in eine Async-Runtime.

Async-Makros

Rust bietet einige Async-Makros, wie zum Beispieltokio::spawn, die verwendet werden, um neue asynchrone Aufgaben in einer Async-Runtime zu starten.

Beispiel

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        // Asynchrone Logik
    });
    handle.await.unwrap();
}

Asynchrone E/A

Rusts Standardbibliothek bietet asynchrone E/A-Operationen, wie zum Beispieltokio::fs::Fileundasync_std::fs::File。

Beispiel

use tokio::fs::File;
use tokio::io::{self, AsyncReadExt};

#[tokio::main]
async fn main() -> io::Result<()> {
    let mut file = File::open("file.txt").await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;
    println!("Contents: {}", contents);
    OK(())
}

Asynchrone Kanäle

Einige Async-Runtimes in Rust bieten asynchrone Kanäle (wie tokio::sync::mpsc), die das Übergeben von Nachrichten zwischen asynchronen Tasks ermöglichen.

Beispiel

use tokio::sync::mpsc;
use tokio::spawn;

#[tokio::main]
async fn main() {
    let (tx, mut rx) = mpsc::channel(32);

    let child = spawn(async move {
        let response = "Hello, world!".to_string();
        tx.send(response).await.unwrap();
    });

    let response = rx.recv().await.unwrap();
    println!("Received: {}", response);

    child.await.unwrap();
}

Zusammenfassung

Rusts asynchrones Programmiermodell async/await bietet eine prägnante und effiziente Möglichkeit, asynchrone Operationen zu handhaben.

Es ermöglicht Entwicklern, asynchrone Operationen auf eine natürlichere und intuitivere Weise zu handhaben, während die Sicherheit und Leistung von Rust erhalten bleiben.

Durch async/await bietet Rust erstklassige Sprachunterstützung für asynchrone Programmierung, wodurch es einfacher wird, effiziente und lesbare asynchrone Programme zu schreiben.

Andere Erweiterungen