Threads & closures move Threads & move closures

thread::spawn lance un fil qui peut survivre à la fonction qui l'a créé.thread::spawn launches a thread that can outlive the function that created it.

On ouvre le Vol 7 sur la promesse la plus citée de Rust : la « concurrence sans peur ». Le slogan cache une vérité simple — ce n'est pas un nouveau mécanisme, c'est la règle du Vol 1 (aliasing XOR mutation) projetée sur un nouveau terrain : plusieurs threads. thread::spawn prend une closure et la lance sur un fil d'exécution séparé, qui tourne en parallèle du reste. Mais ce fil a une propriété déstabilisante : il peut continuer à tourner après que la fonction qui l'a lancé soit revenue. Tout ce qu'il touche par référence risque alors de pointer vers une donnée déjà détruite — le use-after-free du Vol 2, mais entre threads. C'est pourquoi la closure d'un thread doit, le plus souvent, emporter ses données avec elle : le mot-clé move.We open Vol 7 on Rust's most-quoted promise: 'fearless concurrency'. The slogan hides a simple truth — it's not a new mechanism, it's Vol 1's rule (aliasing XOR mutation) projected onto new ground: several threads. thread::spawn takes a closure and runs it on a separate thread of execution, in parallel with the rest. But that thread has an unsettling property: it can keep running after the function that launched it has returned. Anything it touches by reference then risks pointing at already-destroyed data — Vol 2's use-after-free, but across threads. That's why a thread's closure must, most often, take its data with it: the move keyword.

use std::thread;

let salutation = String::from("bonjour");

let handle = thread::spawn(move || {        // `move` : la closure EMPORTE `salutation`
    println!("{salutation} depuis le thread");
});                                         // le thread tourne EN PARALLÈLE du main

handle.join().unwrap();                     // …et on ATTEND sa fin avant de continuer.
// sans ce join(), main pourrait se terminer le premier — et tout le programme s'arrêter,
// thread compris, avant qu'il n'ait rien affiché.

Une closure qui emprunte refuse de compiler dès qu'on la lance dans un thread.A closure that borrows refuses to compile the moment you launch it in a thread.

Hors d'un thread, une closure capture ce dont elle a besoin de la façon la plus légère possible : par référence si lire suffit, par &mut si elle mute, par valeur seulement si elle y est forcée. C'est le comportement par défaut, et il est commode. Mais passez cette même closure à thread::spawn, et le compilateur durcit brutalement ses exigences : il refuse toute capture par référence avec un E0373 sans appel — « closure may outlive the current function ». La raison est celle du chapitre précédent : le thread peut survivre au scope, donc une référence capturée pourrait pendre. La capture la plus légère devient la plus dangereuse. Le mot move force alors la closure à tout capturer par valeur — à emporter ses données plutôt que les pointer.Outside a thread, a closure captures what it needs in the lightest way possible: by reference if reading suffices, by &mut if it mutates, by value only when forced. That's the default behaviour, and it's convenient. But pass that same closure to thread::spawn, and the compiler abruptly hardens its demands: it refuses any capture by reference with an unappealable E0373 — 'closure may outlive the current function'. The reason is the previous chapter's: the thread can outlive the scope, so a captured reference could dangle. The lightest capture becomes the most dangerous. The move keyword then forces the closure to capture everything by value — to take its data along rather than point at it.

use std::thread;

let donnees = vec![1, 2, 3];

let handle = thread::spawn(|| {             // closure SANS move → capture par référence
    println!("{:?}", donnees);              // ✕ error[E0373]: closure may outlive the current
});                                         //   function, but it borrows `donnees`, which is
                                            //   owned by the current function
handle.join().unwrap();
// le compilateur ne PEUT PAS prouver que le thread finit avant que `donnees` soit détruite.
// une référence qui survivrait à sa donnée, c'est précisément le dangling du Vol 2.

L'erreur ne parle pas de threads ni de data races — elle parle de durées de vie. C'est tout le Vol 2 qui ressurgit : une référence ne doit jamais survivre à sa donnée. Ici, le compilateur n'a aucune preuve que le thread se termine avant la fin du scope de donnees ; faute de preuve, il refuse. Remarquez la finesse : le problème n'est pas que le code provoque un bug, c'est qu'il ne peut pas prouver son absence. En Rust, l'absence de preuve est un refus.The error doesn't mention threads or data races — it mentions lifetimes. All of Vol 2 resurfaces: a reference must never outlive its data. Here, the compiler has no proof the thread ends before donnees's scope does; lacking proof, it refuses. Note the subtlety: the problem isn't that the code causes a bug, it's that it can't prove its absence. In Rust, absence of proof is a refusal.

move est le transfert du Vol 1 — franchissant la frontière d'un thread.move is Vol 1's transfer — crossing a thread's boundary.

move ne fait rien de magique ni de spécifique aux threads. Il force la closure à capturer chaque variable utilisée par valeur : pour un type possédé (String, Vec), c'est un move au sens exact du Vol 1 — la possession se transfère, l'original devient inaccessible ; pour un type Copy (un i32, un bool), c'est une copie, et l'original reste utilisable. La seule nouveauté, c'est où va la valeur : de l'autre côté d'une frontière d'exécution, dans un fil qui tournera seul. Et parce que ce fil peut vivre indéfiniment, la signature de spawn impose une borne que tout ce qui traverse doit respecter : 'static. Comprendre ces deux faces — le move classique, et la borne 'static — c'est comprendre tout ce qui se passe quand une donnée entre dans un thread.move does nothing magical or thread-specific. It forces the closure to capture every used variable by value: for an owned type (String, Vec), that's a move in Vol 1's exact sense — ownership transfers, the original becomes inaccessible; for a Copy type (an i32, a bool), it's a copy, and the original stays usable. The only novelty is where the value goes: across an execution boundary, into a thread that will run on its own. And because that thread may live indefinitely, spawn's signature imposes a bound everything crossing must satisfy: 'static. Understanding these two faces — the classic move, and the 'static bound — is understanding everything that happens when data enters a thread.

use std::thread;

let donnees = vec![1, 2, 3];

let handle = thread::spawn(move || {
    let somme: i32 = donnees.iter().sum();   // le thread POSSÈDE `donnees`
    somme                                    // une closure peut RENDRE une valeur
});

println!("{:?}", donnees);                   // ✕ error[E0382]: borrow of moved value: `donnees`
//   `donnees` a été déplacée dans la closure : c'est le move du Vol 1, à l'identique —
//   mais cette fois la valeur a traversé la frontière d'un thread.

let total = handle.join().unwrap();          // join() rend ce que la closure a retourné : 6

// pourquoi spawn exige 'static : la signature elle-même le dit
pub fn spawn<F, T>(f: F) -> JoinHandle<T>
where
    F: FnOnce() -> T + Send + 'static,       // la closure (et tout ce qu'elle capture)
    T: Send + 'static;                        // doit pouvoir vivre AUSSI LONGTEMPS qu'il faut

// 'static ne veut PAS dire « éternel » : il veut dire « ne dépend d'aucun emprunt
// à durée limitée ». une valeur possédée (String, Vec) est 'static ; une référence
// empruntée &donnees ne l'est pas — d'où le refus du chapitre précédent.

Dégainer Arc pour prêter une donnée locale — qu'un thread scopé emprunterait sans rien copier.Reaching for Arc to lend local data — that a scoped thread would borrow without copying a thing.

Le chapitre précédent a posé une vérité dure : spawn exige 'static, donc on ne peut pas lui prêter une référence vers une variable locale. Le réflexe immédiat — surtout quand on a vu Arc au Vol 6 — est d'emballer la donnée dans un Arc et d'en cloner le pointeur pour chaque thread. Ça compile, ça marche. Mais réfléchissez à ce qu'on vient de payer : une allocation sur le tas, un compteur atomique incrémenté et décrémenté à chaque clone et chaque drop, et la contrainte 'static — tout ça pour une donnée qui ne sort jamais de la fonction, que les threads ne font que lire, et qui sera encore là quand ils auront fini. On a pris l'outil du partage permanent pour un simple prêt temporaire. La réponse de la std s'appelle thread::scope.The previous chapter laid down a hard truth: spawn requires 'static, so you can't lend it a reference to a local variable. The immediate reflex — especially once you've met Arc in Vol 6 — is to wrap the data in an Arc and clone the pointer for each thread. It compiles, it works. But consider what you just paid: a heap allocation, an atomic counter bumped up and down on every clone and every drop, and the 'static constraint — all for data that never leaves the function, that the threads only read, and that will still be there when they're done. You reached for the tool of permanent sharing to do a simple temporary loan. The std's answer is thread::scope.

use std::sync::Arc;
use std::thread;

let donnees = Arc::new(vec![1, 2, 3, 4]);   // on EMBALLE dans un Arc juste pour partager

let d1 = Arc::clone(&donnees);              // un clone du compteur (atomique) par thread
let h1 = thread::spawn(move || {            // chaque thread EMPORTE son Arc
    println!("somme = {}", d1.iter().sum::<i32>());
});
let d2 = Arc::clone(&donnees);
let h2 = thread::spawn(move || {
    println!("max = {:?}", d2.iter().max());
});
h1.join().unwrap();
h2.join().unwrap();
// Arc + comptage atomique + 'static — pour une donnée qui ne quitte JAMAIS la fonction.

use std::thread;

let donnees = vec![1, 2, 3, 4];             // une simple Vec, possédée localement

thread::scope(|s| {                         // un scope qui GARANTIT le join avant d'en sortir
    s.spawn(|| {                            // pas de move : la closure EMPRUNTE `donnees`
        println!("somme = {}", donnees.iter().sum::<i32>());
    });
    s.spawn(|| {                            // un second thread l'emprunte AUSSI
        println!("max = {:?}", donnees.iter().max());   // deux lecteurs → aliasing autorisé
    });
});                                         // ◂ ici, les deux threads ont DÉJÀ joint
// `donnees` est restée locale : prêtée par & à deux threads, sans Arc, sans clone, sans 'static.

thread::scope renverse la contrainte 'static en apportant une garantie que spawn n'avait pas : tous les threads lancés dans le scope sont joints avant que scope ne retourne. Le compilateur le sait, donc il sait qu'aucun thread ne peut survivre à donnees — et il autorise l'emprunt par &, sans 'static. Deux threads qui lisent partagent un emprunt immuable : c'est « aliasing XOR mutation » dans toute sa lettre — autant de & qu'on veut, tant que personne ne mute. Pas d'Arc, pas de clone, pas d'allocation : la donnée reste là où elle est, simplement prêtée.thread::scope reverses the 'static constraint by bringing a guarantee spawn lacked: all threads launched in the scope are joined before scope returns. The compiler knows this, so it knows no thread can outlive donnees — and it allows the borrow by &, with no 'static. Two threads that read share an immutable borrow: that's 'aliasing XOR mutation' to the letter — as many & as you like, as long as nobody mutates. No Arc, no clone, no allocation: the data stays where it is, simply lent.