0Pricing
Learn Rust Coding · Leçon

Introduction à Async/Await

Apprenez les principes fondamentaux des fonctions `async` et des expressions `await` pour écrire du code asynchrone et non bloquant.

Introduction à Async/Await est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 3 leçons au total.

Pourquoi la programmation asynchrone ?

En programmation, les tâches impliquent souvent une attente. Il peut s’agir d’attendre le chargement d’un fichier, la fin d’une requête réseau ou le renvoi des résultats d’une requête de base de données.

Traditionnellement, les programmes se bloquent pendant ces attentes : ils mettent toutes les autres opérations en pause jusqu’à la fin de la tâche. Cela peut rendre les applications lentes et peu réactives.

Quand le code attend…

Considérez cet exemple simple d’opération bloquante. Le programme se mettra en pause pendant 2 secondes avant d’afficher le deuxième message.

Essayez de l’exécuter :

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!");
}

Le coût de l’attente

Dans l’exemple précédent, le programme entier a attendu. S’il s’agissait d’un serveur web, cela signifierait que pendant que la requête d’un utilisateur attend une base de données, aucun autre utilisateur ne pourrait être servi !

La programmation asynchrone permet à votre programme de démarrer une tâche longue, puis de passer à un autre travail au lieu d’attendre. Lorsque la tâche longue est prête, le programme peut la reprendre.

L’approche asynchrone de Rust

Rust fournit de puissantes fonctionnalités de langage pour la programmation asynchrone : les mots-clés async et await.

  • Les fonctions async sont des fonctions spéciales qui peuvent être mises en pause puis reprises.
  • .await s’utilise dans une fonction async pour attendre la fin d’une autre tâche asynchrone sans bloquer le programme entier.

Définir des fonctions `async`

Vous déclarez une fonction asynchrone en ajoutant le mot-clé async avant fn. Une fonction async renvoie toujours une Future.

Une Future est une valeur qui n’est peut-être pas encore prête. Elle représente un calcul qui produira éventuellement un résultat.

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

Mettre en pause avec `.await`

Le mot-clé .await rend la programmation asynchrone non bloquante. Lorsque vous utilisez .await sur une Future, votre fonction async va :

  • Mettre sa propre exécution en pause.
  • Permettre au programme d’effectuer d’autres tâches.
  • Reprendre son exécution dès que la Future attendue est prête.

C’est comme si vous appuyiez sur le bouton pause de votre tâche actuelle pendant qu’une autre tâche se termine.

Exécuter du code asynchrone : les exécuteurs

Une fonction async renvoie une Future, mais elle n’exécute pas immédiatement le code qu’elle contient. Les Futures sont paresseuses.

Pour exécuter réellement une fonction async et sa Future, vous avez besoin d’un exécuteur. Pour les exemples simples, nous pouvons utiliser futures::executor::block_on, qui exécute une Future jusqu’à son terme sur le thread actuel.

Votre premier programme `async`/`await`

Voici comment async, await et un exécuteur simple fonctionnent ensemble. Remarquez que block_on est utilisé dans main pour démarrer le processus asynchrone.

Cet exemple simule un délai asynchrone sans bloquer le thread de la fonction main (en théorie ; block_on lui-même bloque jusqu’à la fin de la future, mais la tâche asynchrone cède elle-même la main).

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.");
}

Comprendre le trait `Future`

Lorsque vous écrivez async fn my_func(), Rust le transforme en réalité en une machine à états qui implémente le trait Future.

Le trait Future possède une méthode principale, poll, qu’un exécuteur appelle à plusieurs reprises pour vérifier si la tâche est prête à avancer. Lorsqu’une Future est utilisée avec .await, elle demande à l’exécuteur d’interroger une autre Future jusqu’à ce qu’elle soit terminée.

Vérification rapide : bases de `async`/`await`

Vous avez appris les bases de async et await. Voyons si vous pouvez identifier leurs rôles principaux.

Récapitulatif et prochaines étapes

Excellent travail ! Vous avez fait vos premiers pas dans la programmation asynchrone avec Rust.

  • Nous avons vu que le code synchrone bloque et fait attendre les programmes.
  • Le code asynchrone permet aux tâches de s’exécuter simultanément sans blocage.
  • Le mot-clé async déclare une fonction asynchrone, qui renvoie une Future.
  • Le mot-clé .await met en pause une fonction async jusqu’à ce qu’une Future soit prête.
  • Un exécuteur (comme block_on) est nécessaire pour exécuter les Futures.

Ensuite, nous découvrirons Tokio, un puissant environnement d’exécution et écosystème pour créer des applications asynchrones concrètes en Rust !

Questions Fréquemment Posées

La leçon « Introduction à Async/Await » est-elle gratuite ?

Oui — le texte complet de « Introduction à Async/Await » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Introduction à Async/Await » ?

Apprenez les principes fondamentaux des fonctions `async` et des expressions `await` pour écrire du code asynchrone et non bloquant. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.

Combien de temps prend la leçon « Introduction à Async/Await » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Introduction à Async/Await
  2. Créer des applications asynchrones avec Tokio
  3. Travailler avec les futurs et les tâches
← Retour à Learn Rust Coding