Opret tråde
Kør kode samtidigt.
Opret tråde er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Hvad er en tråd
En tråd lader dit program køre kode samtidigt. Operativsystemet kan planlægge flere tråde, så arbejdet kan overlappe.
R usts standardbibliotek stiller tråde til rådighed gennem modulet std::thread. Det er native tråde fra operativsystemet, som nogle gange kaldes 1:1-tråde.
I denne lektion lærer du at starte nye tråde og styre, hvordan de kører.
Oprettelse med thread::spawn
Du opretter en ny tråd ved at kalde thread::spawn og give den en closure. Closuren indeholder den kode, som den nye tråd skal køre.
Kaldet returnerer straks en JoinHandle, mens den oprettede tråd kører i baggrunden.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}Main kan afslutte først
Når main returnerer, afsluttes hele processen, selv om oprettede tråde stadig kører.
Programmet ovenfor kan derfor måske kun udskrive hovedmeddelelsen. Baggrundstråden får muligvis ikke mulighed for at køre, før processen afsluttes.
Vi har brug for en måde at vente på, at trådene afsluttes.
Vent med join
Den JoinHandle, som spawn returnerer, har en join-metode. Når du kalder den, blokeres den aktuelle tråd, indtil den oprettede tråd afsluttes.
Det garanterer, at den oprettede tråd kører færdig, før main fortsætter.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Sammenflettet output
Når to tråde kører samtidig, kan deres output blive sammenflettet på uforudsigelige måder. Operativsystemet bestemmer rækkefølgen.
Hvis du kører det samme program to gange, kan rækkefølgen være forskellig. Stol aldrig på en bestemt rækkefølge uden 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();
}Sæt på pause med sleep
Du kan sætte en tråd på pause med thread::sleep, som tager en Duration. Det frigiver CPU’en, så andre tråde kan gøre fremskridt.
Det er nyttigt at sove i eksempler for at gøre sammenfletning mere synlig, men undgå det til egentlig 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));
}Oprettelse af mange tråde
Du kan oprette flere tråde i en løkke og samle deres handles i en vektor.
Senere gennemløber du vektoren og kalder join på hvert handle, så alle tråde afsluttes, før programmet slutter.
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();
}
}Navngivning af tråde med Builder
Typen thread::Builder lader dig konfigurere en tråd, før den oprettes. Du kan angive et navn og en stackstørrelse.
Navngivne tråde gør panikmeddelelser og fejlsøgning nemmere at læse.
use std::thread;
fn main() {
let h = thread::Builder::new()
.name("worker".into())
.spawn(|| {
println!("running in named thread");
})
.unwrap();
h.join().unwrap();
}Panics forbliver i tråden
Hvis en oprettet tråd går i panik, får det som standard ikke hele programmet til at gå ned. Panikken er begrænset til den pågældende tråd.
Når du kalder join på en tråd, der er gået i panik, får du en Err. Det lader den overordnede tråd registrere fejlen.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Oplysninger om den aktuelle tråd
Du kan undersøge den kørende tråd med thread::current. Den returnerer et handle, hvis name-metode giver det eventuelle trådnavn.
Hovedtråden er også en rigtig tråd og hedder normalt main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Returnering af værdier fra tråde
Closuren, som gives til spawn, kan returnere en værdi. Værdien kommer tilbage indpakket i Ok, når du kalder join.
Det er en enkel måde at beregne noget i en anden tråd og læse resultatet senere.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Hurtigt tjek
Test din forståelse af oprettelse af tråde.
Opsamling
Du har lært at starte tråde med thread::spawn og en closure, som returnerer en JoinHandle.
Et kald til join venter på, at tråden afsluttes, og giver returværdien eller en panik videre. Output fra tråde kan blive sammenflettet på uforudsigelige måder, og Builder lader dig navngive tråde.
Dernæst ser du, hvordan du flytter data ind i de tråde, du opretter.
Lær Rust med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 39
- Lektioner
- 144
Ofte stillede spørgsmål
Er lektionen “Opret tråde” gratis?
Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “Opret tråde”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Opret tråde”?
Kør kode samtidigt. Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Lær at programmere i Rust?
Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Opret tråde”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?
Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.