Programmation asynchrone Rust async/await

Dans la programmation moderne, la programmation asynchrone devient de plus en plus importante car elle permet aux programmes de ne pas être bloqués pendant l'attente d'opérations d'E/S (telles que la lecture/écriture de fichiers, la communication réseau, etc.), améliorant ainsi les performances et la réactivité.

La programmation asynchrone est une façon de gérer les opérations non bloquantes en Rust, permettant aux programmes de ne pas être bloqués lors de l'exécution d'opérations d'E/S de longue durée, mais de pouvoir exécuter d'autres tâches pendant l'attente.

Rust fournit une variété d'outils et de bibliothèques pour la programmation asynchrone, notammentasyncetawaitmots-clés,futureset les runtimes asynchrones (tels que tokio, async-std, etc.), et d'autres outils auxiliaires.

  • Future: Future est une abstraction en Rust qui représente une opération asynchrone. C'est un calcul qui peut ne pas encore être terminé, et qui retournera une valeur ou une erreur à un moment donné dans le futur.

  • async/await:asyncLe mot-clé est utilisé pour définir une fonction asynchrone, qui renvoie un Future.awaitLe mot-clé est utilisé pour suspendre l'exécution du Future actuel jusqu'à ce qu'il se termine.

Exemple

L'exemple suivant montre comment utiliser les mots-clés async et await pour écrire une fonction asynchrone, et comment exécuter une tâche asynchrone dans une fonction asynchrone et attendre qu'elle se termine.

Exemple

// Importer les dépendances requises
use tokio;
use tokio::time::{self, Duration};

// Fonction asynchrone, simulant une tâche asynchrone
async fn async_task() -> u32 {
    // Simuler une opération asynchrone, attendre 1 seconde
    time::sleep(Duration::from_secs(1)).await;
    // Retourner le résultat
    42
}

// Fonction d'exécution de tâche asynchrone
async fn execute_async_task() {
    // Appeler la tâche asynchrone et attendre qu'elle se termine
    let result = async_task().await;
    // Afficher le résultat
    println!("Résultat de la tâche asynchrone : {}", result);
}

// Fonction principale
#[tokio::main]
async fn main() {
    println!("Début de l'exécution de la tâche asynchrone...");
    // Appeler la fonction d'exécution de la tâche asynchrone et attendre qu'elle se termine
    execute_async_task().await;
    println!("Tâche asynchrone terminée !");
}

Dans le code ci-dessus, nous avons d'abord défini une fonction asynchroneasync_task(), qui simule une opération asynchrone, en utilisanttokio::time::delay_for()méthode pour attendre 1 seconde, puis renvoie le résultat 42. Ensuite, nous avons défini une fonction d'exécution de tâche asynchroneexecute_async_task(), dans laquelle nous avons appelé la fonction asynchrone et utiliséawaitmot-clé pour attendre la fin de la tâche asynchrone. Enfin, dansmainfonction, utiliseztokio::mainmacro pour exécuter la fonction d'exécution de tâche asynchrone et attendre sa fin.

En exécutant ce programme, vous pouvez voir que le programme affiche un message indiquant qu'il a commencé à exécuter la tâche asynchrone, puis, après avoir attendu 1 seconde, affiche le résultat de la tâche asynchrone, et enfin affiche un message indiquant que la tâche asynchrone est terminée :

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

Cet exemple démontre l'utilisation deasyncetawaitmots-clés pour écrire des fonctions asynchrones, et comment exécuter des tâches asynchrones dans des fonctions asynchrones et attendre leur fin.

L'exemple suivant utilise la bibliothèque tokio pour effectuer une requête HTTP asynchrone et affiche la réponse :

Exemple 2

// Importer les dépendances requises
use std::error::Error;
use tokio::runtime::Runtime;
use reqwest::get;

// Fonction asynchrone pour effectuer une requête HTTP GET et renvoyer la réponse
async fn fetch_url(url: &str) -> Result<String, Box<dyn Error>> {
    // Utiliser reqwest pour effectuer une requête HTTP GET asynchrone
    let response = get(url).await?;
    let body = response.text().await?;
    Ok(body)
}

// Fonction d'exécution de tâche asynchrone
async fn execute_async_task() -> Result<(), Box<dyn Error>> {
    // Effectuer une requête HTTP asynchrone
    let url = "https://jsonplaceholder.typicode.com/posts/1";
    let result = fetch_url(url).await?;
    // Afficher la réponse
    println!("Réponse : {}", result);
    OK(())
}

// Fonction principale
fn main() {
    // Créer un runtime asynchrone
    let rt = Runtime::new().unwrap();
    // Exécuter la tâche asynchrone dans le runtime asynchrone
    let result = rt.block_on(execute_async_task());
    // Gérer le résultat d'exécution de la tâche asynchrone
    match result {
        Ok(_) => println!("Tâche asynchrone exécutée avec succès !"),
        Err(e) => eprintln!("Erreur : {}", e),
    }
}

Dans le code ci-dessus, nous avons d'abord importé les bibliothèques tokio et reqwest, qui servent respectivement à exécuter des tâches asynchrones et à effectuer des requêtes HTTP. Ensuite, nous avons défini une fonction asynchrone fetch_url, qui permet d'effectuer une requête HTTP GET asynchrone et de renvoyer la réponse.

Ensuite, nous avons défini une fonction d'exécution de tâche asynchrone execute_async_task, qui effectue une requête HTTP asynchrone et affiche la réponse.

Enfin, dans la fonction main, nous avons créé un runtime asynchrone tokio, exécuté la tâche asynchrone à l'intérieur de celui-ci, et géré le résultat d'exécution de la tâche asynchrone.

En exécutant ce programme, vous pouvez voir que la réponse de la requête HTTP asynchrone est affichée. Dans l'exemple, il a récupéré les données d'un post depuis JSONPlaceholder et a imprimé son contenu.


Explication de la programmation asynchrone

mot-clé async

Le mot-clé async est utilisé pour définir des fonctions asynchrones, c'est-à-dire des fonctions qui renvoient un type Future ou impl Future. Lorsqu'une fonction asynchrone est exécutée, elle renvoie un objet Future inachevé, qui représente un calcul ou une opération qui n'est pas encore terminée.

Les fonctions asynchrones peuvent contenir des expressions await, qui sont utilisées pour attendre que d'autres opérations asynchrones se terminent.

Exemple

async fn hello() -> String {
    "Bonjour, le monde !".to_string()
}

mot-clé await

Le mot-clé await est utilisé pour attendre la fin d'une opération asynchrone et obtenir son résultat.

L'expression await ne peut être utilisée que dans les fonctions async ou les blocs async. Elle suspend l'exécution de la fonction async en cours, attend que le Future attendu soit terminé, puis continue à exécuter le code suivant.

Exemple

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

Valeur de retour d'une fonction async

Le type de retour d'une fonction async est généralementimpl Future<Output = T>, oùTest le type de résultat de l'opération asynchrone. Comme la valeur de retour d'une fonction async est un Future, vous pouvez utiliser.awaitpour attendre la fin de l'opération asynchrone et obtenir son résultat.

Exemple

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

Bloc async

En plus de définir des fonctions async, Rust fournit également une syntaxe de bloc async, permettant d'utiliser des opérations asynchrones dans du code synchrone. Un bloc async est constitué deasync { }, qui peut contenir des appels de fonctions async etawaitexpressions.

Exemple

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

Exécution de tâches asynchrones

En Rust, les tâches async doivent généralement s'exécuter dans un contexte d'exécution. Vous pouvez utilisertokio::main、async-stddetask::block_onoufutures::executor::block_onet d'autres fonctions pour exécuter des tâches async. Ces fonctions acceptent une fonction async ou un bloc async et l'exécutent dans le thread courant ou l'environnement d'exécution.

Exemple

use async_std::task;

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

Gestion des erreurs

awaitsuivi d'un?peut propager des erreurs. SiawaitFuture se termine avec une erreur, alors cette erreur sera propagée à l'appelant.

Exemple

async fn my_async_function() -> Result<(), MyError> {
    some_async_operation().await?;
    // Si some_async_operation échoue, l'erreur sera propagée
}

Méthodes asynchrones de trait

Rust permet de définir des méthodes asynchrones pour des traits. Cela vous permet de définir des opérations asynchrones pour des objets de différents types.

Exemple

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

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

Contexte asynchrone

En Rust, le code asynchrone est généralement exécuté dans un environnement d'exécution asynchrone (comme Tokio ou async-std). Ces environnements d'exécution fournissent des mécanismes pour planifier et exécuter des tâches asynchrones.

Exemple

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

Dans le code ci-dessus,#[tokio::main]La macro d'attribut enveloppemain,la fonction, dans un environnement d'exécution asynchrone.

Macros asynchrones

Rust fournit quelques macros asynchrones, telles quetokio::spawn, qui sont utilisées pour démarrer de nouvelles tâches asynchrones dans un environnement d'exécution asynchrone.

Exemple

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

E/S asynchrones

La bibliothèque standard de Rust fournit des opérations d'E/S asynchrones, telles quetokio::fs::Fileetasync_std::fs::File。

Exemple

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!("Contenu : {}", contents);
    OK(())
}

Canaux asynchrones

Certains environnements d'exécution asynchrones en Rust fournissent des canaux asynchrones (tels que tokio::sync::mpsc), qui permettent de transmettre des messages entre tâches asynchrones.

Exemple

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 = "Bonjour, monde !".to_string();
        tx.send(response).await.unwrap();
    });

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

    child.await.unwrap();
}

Résumé

Le modèle de programmation asynchrone async/await de Rust offre un moyen concis et efficace de gérer les opérations asynchrones.

Il permet aux développeurs de gérer les opérations asynchrones de manière plus naturelle et intuitive, tout en conservant la sécurité et les performances de Rust.

Grâce à async/await, Rust fournit une prise en charge de premier ordre au niveau du langage pour la programmation asynchrone, ce qui facilite l'écriture de programmes asynchrones efficaces et lisibles.

Autres extensions