Creare thread
Esegua il codice in concorrenza.
Creare thread è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
Che cos'è un thread?
Un thread consente al programma di eseguire codice in concorrenza. Il sistema operativo può pianificare più thread, permettendo alle attività di sovrapporsi.
La libreria standard di Rust espone i thread tramite il modulo std::thread. Si tratta di thread nativi del sistema operativo, talvolta chiamati thread 1:1.
In questa lezione imparerà ad avviare nuovi thread e a controllarne l'esecuzione.
Creare thread con thread::spawn
Si crea un nuovo thread chiamando thread::spawn e passandogli una closure. La closure contiene il codice che il nuovo thread eseguirà.
La chiamata restituisce immediatamente un JoinHandle, mentre il thread creato viene eseguito in background.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}main potrebbe terminare per prima
Quando main restituisce il controllo, l'intero processo termina, anche se i thread creati sono ancora in esecuzione.
Perciò il programma precedente potrebbe stampare solo il messaggio del thread principale. Il thread in background potrebbe non avere il tempo di essere eseguito prima della chiusura del processo.
Serve un modo per attendere il completamento dei thread.
Attendere con join
Il JoinHandle restituito da spawn dispone di un metodo join. Chiamandolo, il thread corrente rimane bloccato finché il thread creato non termina.
In questo modo si garantisce che il thread creato completi l'esecuzione prima che main prosegua.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Output intercalato
Quando due thread vengono eseguiti contemporaneamente, il loro output può intercalarsi in modi imprevedibili. È il sistema operativo a decidere la pianificazione.
Eseguendo due volte lo stesso programma si possono ottenere ordini diversi. Non faccia mai affidamento su un ordine specifico senza sincronizzazione.
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();
}Mettere in pausa con sleep
È possibile mettere in pausa un thread con thread::sleep, che accetta una Duration. In questo modo la CPU viene lasciata libera, consentendo agli altri thread di avanzare.
La sospensione è utile negli esempi per rendere più visibile l'intercalazione, ma eviti di usarla per la sincronizzazione reale.
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));
}Creare molti thread
È possibile creare diversi thread in un ciclo e raccogliere i relativi handle in un vettore.
In seguito si scorre il vettore e si esegue join su ogni handle, assicurandosi che tutti i thread completino l'esecuzione prima della fine del programma.
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();
}
}Dare un nome ai thread con Builder
Il tipo thread::Builder consente di configurare un thread prima di crearlo. È possibile impostare un nome e la dimensione dello stack.
I thread con nome rendono più leggibili i messaggi di panic e facilitano il debugging.
use std::thread;
fn main() {
let h = thread::Builder::new()
.name("worker".into())
.spawn(|| {
println!("running in named thread");
})
.unwrap();
h.join().unwrap();
}I panic rimangono nel thread
Se un thread creato va in panic, per impostazione predefinita non manda in crash l'intero programma. Il panic rimane confinato a quel thread.
Quando si chiama join su un thread che è andato in panic, si ottiene un Err. In questo modo il thread padre può rilevare l'errore.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Informazioni sul thread corrente
È possibile esaminare il thread in esecuzione con thread::current. Restituisce un handle il cui metodo name fornisce il nome opzionale del thread.
Anche il thread principale è un thread reale e di solito si chiama main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Restituire valori dai thread
La closure passata a spawn può restituire un valore. Quando si chiama join, tale valore viene restituito avvolto in Ok.
È un modo semplice per calcolare qualcosa in un altro thread e leggere il risultato in seguito.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Verifica rapida
Verifichi la Sua comprensione della creazione dei thread.
Riepilogo
Ha imparato ad avviare thread con thread::spawn e una closure, ottenendo un JoinHandle.
La chiamata a join attende il completamento e restituisce il valore di ritorno oppure segnala un panic. L'output dei thread può intercalarsi in modo imprevedibile e Builder consente di assegnare loro un nome.
Ora vedrà come spostare i dati nei thread creati.
Domande Frequenti
La lezione «Creare thread» è gratuita?
Sì — il testo completo di «Creare thread» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Creare thread»?
Esegua il codice in concorrenza. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Creare thread»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Creare thread
- Spostare i dati nei thread
- Condividere con Arc e Mutex
- Unire i thread e raccogliere i risultati