Partager avec Arc et Mutex
Modifiez l’état partagé en toute sécurité.
Partager avec Arc et Mutex est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 3 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.
La nécessité d’un état partagé
Il arrive que plusieurs threads doivent lire ou mettre à jour les mêmes données. Déplacer la propriété vers un seul thread ne suffit pas.
Rust fournit une propriété partagée sûre entre threads avec Arc, ainsi qu’une modification sûre avec Mutex. Ensemble, ils permettent de gérer un état partagé et modifiable.
Arc : comptage atomique des références
Arc signifie « compté atomiquement par référence ». Il ressemble à Rc, mais son compteur utilise des opérations atomiques ; il est donc sûr entre les threads.
Cloner un Arc ne copie pas les données. Cela incrémente seulement le compteur et renvoie un autre handle vers la même valeur.
use std::sync::Arc;
fn main() {
let shared = Arc::new(vec![1, 2, 3]);
let clone = Arc::clone(&shared);
println!("{:?} {:?}", shared, clone);
}Partager Arc entre les threads
Pour partager des données en lecture seule, clonez le Arc une fois par thread et déplacez chaque clone dans celui-ci. Tous les threads pointent vers la même allocation.
Comme Arc est Send et Sync, ce code compile correctement.
use std::sync::Arc;
use std::thread;
fn main() {
let data = Arc::new(vec![10, 20, 30]);
let mut handles = vec![];
for i in 0..3 {
let d = Arc::clone(&data);
handles.push(thread::spawn(move || println!("{}", d[i])));
}
for h in handles { h.join().unwrap(); }
}Arc seul est en lecture seule
Arc vous donne une propriété partagée, mais uniquement un accès partagé et immuable à la valeur interne.
Vous ne pouvez pas modifier directement des données via un Arc, car plusieurs threads qui le détiennent simultanément provoqueraient une course. Vous avez besoin d’une mutabilité interne avec un verrou.
Mutex : exclusion mutuelle
Un Mutex protège les données afin qu’un seul thread puisse y accéder à la fois. Vous appelez lock pour obtenir cet accès.
lock renvoie un Result ; le déballage fournit un garde-pointeur intelligent. Les autres threads sont bloqués jusqu’à la suppression du garde.
use std::sync::Mutex;
fn main() {
let m = Mutex::new(0);
{
let mut guard = m.lock().unwrap();
*guard += 5;
}
println!("{:?}", m);
}Le garde et RAII
La valeur renvoyée par lock est un MutexGuard. Vous accédez aux données internes en la déréférençant avec *.
Lorsque le garde sort de sa portée, le verrou est automatiquement libéré. Ce style RAII évite d’oublier de déverrouiller.
Combiner Arc et Mutex
Pour partager un état modifiable entre les threads, enveloppez un Mutex dans un Arc. Le Arc partage la propriété ; le Mutex protège les modifications.
Ce modèle, Arc<Mutex<T>>, est la manière standard de gérer un état partagé et modifiable en Rust.
use std::sync::{Arc, Mutex};
fn main() {
let counter = Arc::new(Mutex::new(0));
let c = Arc::clone(&counter);
*c.lock().unwrap() += 1;
println!("{}", *counter.lock().unwrap());
}Un compteur partagé
Ici, dix threads incrémentent chacun un compteur partagé. Chacun clone le Arc, verrouille le Mutex et ajoute un.
Comme le verrou sérialise les accès, le total final est toujours exactement égal à dix.
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..10 {
let c = Arc::clone(&counter);
handles.push(thread::spawn(move || {
*c.lock().unwrap() += 1;
}));
}
for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap());
}Garder les sections critiques courtes
Le code exécuté pendant qu’un verrou est détenu constitue la section critique. Les autres threads y attendent ; gardez-la donc courte.
Verrouillez, effectuez la mise à jour minimale, puis libérez le verrou. Évitez les calculs lourds ou les entrées-sorties pendant que vous le détenez.
use std::sync::Mutex;
fn main() {
let m = Mutex::new(Vec::new());
{
let mut v = m.lock().unwrap();
v.push(1);
} // lock released here
println!("{:?}", m.lock().unwrap());
}Interblocages et empoisonnement
Si un thread verrouille deux fois le même Mutex, ou si deux threads verrouillent deux mutex dans des ordres opposés, vous pouvez provoquer un interblocage et bloquer le programme indéfiniment.
Si un thread déclenche une panique alors qu’il détient un verrou, le Mutex devient empoisonné et les appels ultérieurs à lock renvoient un Err.
RwLock pour de nombreux lecteurs
Lorsque les lectures sont largement plus nombreuses que les écritures, RwLock peut être préférable à Mutex. Il autorise de nombreux lecteurs simultanés ou un seul rédacteur exclusif.
Utilisez read pour un accès partagé et write pour un accès exclusif.
use std::sync::RwLock;
fn main() {
let lock = RwLock::new(5);
{
let r = lock.read().unwrap();
println!("read {}", *r);
}
*lock.write().unwrap() += 1;
println!("{}", *lock.read().unwrap());
}Vérification rapide
Vérifiez votre compréhension de Arc et Mutex.
Récapitulatif
Vous avez appris que Arc partage la propriété entre les threads grâce au comptage atomique des références, mais n’autorise qu’un accès immuable.
Un Mutex protège les modifications et fournit un garde qui libère le verrou lors de sa suppression. Combinez-les sous la forme Arc<Mutex<T>> pour obtenir un état partagé et modifiable, tout en surveillant les interblocages et l’empoisonnement.
Vous allez maintenant joindre les threads et collecter leurs résultats.
Questions Fréquemment Posées
La leçon « Partager avec Arc et Mutex » est-elle gratuite ?
Oui — le texte complet de « Partager avec Arc et Mutex » 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 « Partager avec Arc et Mutex » ?
Modifiez l’état partagé en toute sécurité. 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 3 sur 4.
Combien de temps prend la leçon « Partager avec Arc et Mutex » ?
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