0Pricing
Learn Rust Coding · Leçon

Créer des applications asynchrones avec Tokio

Utilisez l’environnement d’exécution Tokio pour exécuter efficacement des tâches asynchrones et gérer les entrées-sorties ainsi que d’autres opérations concurrentes.

Créer des applications asynchrones avec Tokio est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 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.

Découvrez l’environnement d’exécution Tokio

Bon retour ! Dans la leçon précédente, vous avez découvert async et await. Mais comment une fonction async s’exécute-t-elle réellement ?

C’est là qu’intervient un environnement d’exécution asynchrone comme Tokio. Tokio est une bibliothèque puissante qui fournit l’environnement d’exécution de votre code Rust asynchrone.

  • Elle planifie et exécute les Futures.
  • Elle gère les opérations d’E/S non bloquantes.
  • Elle gère efficacement les tâches concurrentes.

Exécuter votre code asynchrone

Pour commencer avec Tokio, vous utilisez généralement la macro d’attribut #[tokio::main]. Cette macro transforme votre async fn main() en une fonction fn main() standard qui initialise l’environnement d’exécution Tokio et exécute votre code asynchrone.

Considérez-la comme le point d’entrée de votre application asynchrone.

use tokio;

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

Créer de nouvelles tâches asynchrones

L’une des fonctionnalités essentielles de Tokio est la possibilité d’exécuter plusieurs opérations asynchrones simultanément. Vous pouvez y parvenir avec tokio::spawn.

tokio::spawn reçoit une Future et planifie son exécution dans l’environnement Tokio. Votre tâche principale peut ainsi continuer à s’exécuter pendant que la tâche créée s’exécute en arrière-plan.

  • Elle est non bloquante.
  • Elle renvoie un JoinHandle permettant d’attendre sa fin.
  • Les tâches s’exécutent indépendamment.

<code>tokio::spawn</code> en action

Voyons comment tokio::spawn vous permet d’exécuter du code simultanément. Remarquez que les deux messages apparaissent, mais que le message « done » peut s’afficher avant le message « task complete » en raison de la pause.

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

Attendre plusieurs tâches

Lorsque vous avez plusieurs tâches, vous devez souvent attendre qu’elles soient toutes terminées. Tokio fournit la macro tokio::join! à cet effet.

tokio::join! permet d’attendre simultanément plusieurs futures et de combiner leurs résultats. Cela ressemble à l’utilisation de `await` sur plusieurs JoinHandle, mais c’est souvent plus concis pour des ensembles fixes de futures.

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

E/S de fichiers asynchrone avec Tokio

Les opérations traditionnelles sur les fichiers peuvent bloquer le thread, ce qui est problématique pour les applications asynchrones. Le module tokio::fs de Tokio fournit des versions asynchrones des opérations sur le système de fichiers.

Votre application peut ainsi rester réactive, même lorsqu’elle lit de gros fichiers ou effectue de nombreuses opérations sur des fichiers, car les E/S sont gérées de manière non bloquante.

  • tokio::fs::read_to_string
  • tokio::fs::write
  • tokio::fs::File pour un contrôle accru

Lire un fichier de manière asynchrone

Voici comment lire un fichier de manière asynchrone avec tokio::fs::read_to_string. Pour que ce code s’exécute, assurez-vous d’avoir un fichier nommé hello.txt dans le même répertoire que votre projet Rust (par exemple dans src/ ou à la racine du projet), contenant du texte.

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),
  }
}

Opérations réseau asynchrones

Tokio révèle tout son potentiel dans la programmation réseau. Son module tokio::net propose des primitives non bloquantes pour les communications TCP et UDP.

C’est essentiel pour créer des serveurs ou des clients très performants capables de gérer de nombreuses connexions simultanément, sans thread distinct pour chacune.

  • tokio::net::TcpListener pour les serveurs.
  • tokio::net::TcpStream pour les connexions client.

Structure de base d’un serveur TCP asynchrone

Bien qu’un serveur complet soit complexe, cet extrait montre la boucle principale d’un serveur TCP asynchrone utilisant Tokio. Il écoute les connexions entrantes et affiche un message pour chacune d’elles. Essayez de l’exécuter, puis ouvrez votre navigateur à l’adresse http://127.0.0.1:8080 pour voir les connexions.

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

Défi sur les tâches Tokio

Considérez le code Rust suivant utilisant Tokio. Quel sera le premier message affiché dans la console lors de l'exécution de ce programme ?

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écapitulatif&nbsp;: créer des programmes avec Tokio

Vous avez franchi une étape importante dans la création d'applications asynchrones avec Rust et Tokio !

  • Tokio joue le rôle de moteur d'exécution asynchrone et exécute votre code async.
  • #[tokio::main] est le point d'entrée asynchrone de votre programme.
  • tokio::spawn vous permet d'exécuter plusieurs tâches simultanément.
  • tokio::join! vous aide à attendre plusieurs futurs.
  • Tokio fournit des entrées-sorties non bloquantes pour les fichiers (tokio::fs) et les réseaux (tokio::net).

Ces outils sont fondamentaux pour créer des applications Rust hautement concurrentes et réactives. Continuez à vous entraîner !

Questions Fréquemment Posées

La leçon « Créer des applications asynchrones avec Tokio » est-elle gratuite ?

Oui — le texte complet de « Créer des applications asynchrones avec Tokio » 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 « Créer des applications asynchrones avec Tokio » ?

Utilisez l’environnement d’exécution Tokio pour exécuter efficacement des tâches asynchrones et gérer les entrées-sorties ainsi que d’autres opérations concurrentes. 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 2 sur 3.

Combien de temps prend la leçon « Créer des applications asynchrones avec Tokio » ?

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