Créer des threads
Exécutez du code en parallèle.
Créer des threads est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. 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 4 leçons au total.
Qu’est-ce qu’un thread ?
Un thread permet à votre programme d’exécuter du code simultanément. Le système d’exploitation peut planifier plusieurs threads, ce qui permet aux tâches de se chevaucher.
La bibliothèque standard de Rust expose les threads via le module std::thread. Il s’agit de threads natifs de l’OS, parfois appelés threads 1:1.
Dans cette leçon, vous apprendrez à démarrer de nouveaux threads et à contrôler leur exécution.
Créer un thread avec thread::spawn
Vous créez un nouveau thread en appelant thread::spawn et en lui transmettant une fermeture. Cette fermeture contient le code que le nouveau thread exécutera.
L’appel renvoie immédiatement un JoinHandle, tandis que le thread créé s’exécute en arrière-plan.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}main peut se terminer en premier
Lorsque main renvoie une valeur, l’ensemble du processus se termine, même si des threads créés sont encore en cours d’exécution.
Ainsi, le programme ci-dessus pourrait n’afficher que le message de main. Le thread en arrière-plan pourrait ne pas avoir le temps de s’exécuter avant la fin du processus.
Nous avons besoin d’un moyen d’attendre la fin des threads.
Attendre avec join
Le JoinHandle renvoyé par spawn possède une méthode join. Son appel bloque le thread actuel jusqu’à la fin du thread créé.
Cela garantit que le thread créé s’exécute jusqu’à son terme avant que main ne poursuive son exécution.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Entrelacement de la sortie
Lorsque deux threads s’exécutent simultanément, leur sortie peut s’entrelacer de manière imprévisible. L’OS décide de l’ordre d’exécution.
Exécuter deux fois le même programme peut produire des ordres différents. Ne vous fiez jamais à un ordre précis sans synchronisation.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
for i in 1..4 {
println!("thread: {}", i);
}
});
for i in 1..4 {
println!("main: {}", i);
}
handle.join().unwrap();
}Mettre en pause avec sleep
Vous pouvez mettre un thread en pause avec thread::sleep, qui accepte une Duration. Cela libère le CPU afin que les autres threads puissent progresser.
La mise en pause est utile dans les exemples pour rendre l’entrelacement plus visible, mais évitez-la pour la synchronisation réelle.
use std::thread;
use std::time::Duration;
fn main() {
thread::spawn(|| {
for i in 1..4 {
println!("spawned: {}", i);
thread::sleep(Duration::from_millis(1));
}
});
thread::sleep(Duration::from_millis(10));
}Créer de nombreux threads
Vous pouvez créer plusieurs threads dans une boucle et collecter leurs handles dans un vecteur.
Vous parcourez ensuite le vecteur et appelez join sur chaque handle, ce qui garantit que tous les threads se terminent avant la fin du programme.
use std::thread;
fn main() {
let mut handles = vec![];
for id in 0..3 {
let h = thread::spawn(move || {
println!("thread {}", id);
});
handles.push(h);
}
for h in handles {
h.join().unwrap();
}
}Nommer des threads avec Builder
Le type thread::Builder vous permet de configurer un thread avant sa création. Vous pouvez définir un nom et une taille de pile.
Les threads nommés rendent les messages de panique et le débogage plus faciles à comprendre.
use std::thread;
fn main() {
let h = thread::Builder::new()
.name("worker".into())
.spawn(|| {
println!("running in named thread");
})
.unwrap();
h.join().unwrap();
}Les paniques restent dans le thread
Si un thread créé déclenche une panique, cela ne fait pas planter tout le programme par défaut. La panique reste confinée à ce thread.
Lorsque vous appelez join sur un thread ayant paniqué, vous obtenez un Err. Le thread parent peut ainsi détecter l’échec.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Informations sur le thread actuel
Vous pouvez examiner le thread en cours d’exécution avec thread::current. Cette fonction renvoie un handle dont la méthode name fournit le nom éventuel du thread.
Le thread principal est lui aussi un véritable thread, généralement nommé main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Renvoyer des valeurs depuis des threads
La fermeture transmise à spawn peut renvoyer une valeur. Cette valeur est renvoyée dans un Ok lorsque vous appelez join.
C’est un moyen simple d’effectuer un calcul dans un autre thread, puis d’en lire le résultat ultérieurement.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Vérification rapide
Vérifiez votre compréhension de la création de threads.
Récapitulatif
Vous avez appris à démarrer des threads avec thread::spawn et une fermeture, ce qui renvoie un JoinHandle.
L’appel de join attend la fin de l’exécution et fournit la valeur renvoyée ou une panique. La sortie des threads peut s’entrelacer de manière imprévisible, et Builder permet de nommer les threads.
Vous allez maintenant découvrir comment déplacer des données dans les threads que vous créez.
Questions Fréquemment Posées
La leçon « Créer des threads » est-elle gratuite ?
Oui — le texte complet de « Créer des threads » 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 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Créer des threads » ?
Exécutez du code en parallèle. 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 4.
Combien de temps prend la leçon « Créer des threads » ?
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
- Créer des threads
- Déplacer des données dans des threads
- Partager avec Arc et Mutex
- Rejoindre les threads et recueillir les résultats