Skapa trådar
Kör kod samtidigt.
Skapa trådar är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad är en tråd?
En tråd låter programmet köra kod samtidigt med annan kod. Operativsystemet kan schemalägga flera trådar, så arbete kan överlappa.
R全st standardbibliotek tillhandahåller trådar via modulen std::thread. Det här är trådar i operativsystemet, ibland kallade 1:1-trådar.
I den här lektionen lär ni er att starta nya trådar och styra hur de körs.
Skapa trådar med thread::spawn
Ni skapar en ny tråd genom att anropa thread::spawn och skicka med en closure. Closuren innehåller koden som den nya tråden ska köra.
Anropet returnerar omedelbart ett JoinHandle, medan den skapade tråden körs i bakgrunden.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}Main kan avslutas först
När main returnerar avslutas hela processen, även om skapade trådar fortfarande körs.
Programmet ovan kanske därför bara skriver ut huvudmeddelandet. Bakgrundstråden kanske inte hinner köras innan processen avslutas.
Vi behöver ett sätt att vänta på att trådarna ska bli klara.
Vänta med join
Det JoinHandle som returneras av spawn har en metod som heter join. När ni anropar den blockeras den aktuella tråden tills den skapade tråden är klar.
Det garanterar att den skapade tråden körs färdigt innan main fortsätter.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Sammanflätad utskrift
När två trådar körs samtidigt kan deras utskrifter sammanflätas på oförutsägbara sätt. Operativsystemet avgör schemaläggningen.
Om samma program körs två gånger kan utskrifterna komma i olika ordning. Förlita er aldrig på en viss ordning utan synkronisering.
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();
}Pausa med sleep
Ni kan pausa en tråd med thread::sleep, som tar emot en Duration. Det lämnar över processorn så att andra trådar kan fortsätta arbeta.
Att sova är användbart i exempel för att göra sammanflätningen tydligare, men undvik det för faktisk synkronisering.
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));
}Skapa många trådar
Ni kan skapa flera trådar i en loop och samla deras handles i en vektor.
Senare itererar ni över vektorn och anropar join på varje handle, så att alla trådar blir klara innan programmet avslutas.
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();
}
}Namnge trådar med Builder
Typen thread::Builder låter er konfigurera en tråd innan den skapas. Ni kan ange ett namn och en stackstorlek.
Namngivna trådar gör panic-meddelanden och felsökning lättare att läsa.
use std::thread;
fn main() {
let h = thread::Builder::new()
.name("worker".into())
.spawn(|| {
println!("running in named thread");
})
.unwrap();
h.join().unwrap();
}Panics stannar i tråden
Om en skapad tråd får en panic kraschar inte hela programmet som standard. Panicen stannar i den tråden.
När ni anropar join på en tråd som fått en panic får ni en Err. Det låter den överordnade tråden upptäcka felet.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Information om aktuell tråd
Ni kan undersöka den tråd som körs med thread::current. Den returnerar ett handle vars metod name ger trådens eventuella namn.
Huvudtråden är också en riktig tråd och heter vanligtvis main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Returnera värden från trådar
Closuren som skickas till spawn kan returnera ett värde. När ni anropar join returneras värdet inuti Ok.
Det här är ett enkelt sätt att beräkna något i en annan tråd och läsa resultatet senare.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Snabbtest
Testa er förståelse av hur trådar skapas.
Sammanfattning
Ni har lärt er att starta trådar med thread::spawn och en closure, vilket returnerar ett JoinHandle.
Att anropa join väntar på att tråden ska bli klar och gör returvärdet eller en panic tillgänglig. Utskrifter från olika trådar kan sammanflätas på oförutsägbara sätt, och Builder låter er namnge trådar.
Härnäst får ni se hur data flyttas in i trådarna ni skapar.
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Skapa trådar” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Skapa trådar”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad lär jag mig i ”Skapa trådar”?
Kör kod samtidigt. Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Skapa trådar”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.