Threads erzeugen
Führen Sie Code nebenläufig aus.
Threads erzeugen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was ist ein Thread?
Ein Thread ermöglicht es Ihrem Programm, Code gleichzeitig auszuführen. Das Betriebssystem kann mehrere Threads einplanen, sodass sich Arbeit überschneiden kann.
Die Standardbibliothek von Rust stellt Threads über das Modul std::thread bereit. Dabei handelt es sich um native Betriebssystem-Threads, die manchmal als 1:1-Threads bezeichnet werden.
In dieser Lektion lernen Sie, neue Threads zu starten und ihre Ausführung zu steuern.
Threads mit thread::spawn starten
Sie erstellen einen neuen Thread, indem Sie thread::spawn aufrufen und ihm eine Closure übergeben. Die Closure enthält den Code, den der neue Thread ausführen soll.
Der Aufruf gibt sofort ein JoinHandle zurück, während der gestartete Thread im Hintergrund läuft.
use std::thread;
fn main() {
thread::spawn(|| {
println!("hello from a thread");
});
println!("hello from main");
}main kann zuerst fertig werden
Wenn main zurückkehrt, endet der gesamte Prozess, selbst wenn gestartete Threads noch laufen.
Das Programm oben gibt daher möglicherweise nur die Nachricht aus main aus. Der Hintergrund-Thread erhält eventuell keine Gelegenheit mehr zu laufen, bevor der Prozess endet.
Wir benötigen eine Möglichkeit, auf das Ende der Threads zu warten.
Mit join warten
Das von spawn zurückgegebene JoinHandle besitzt eine join-Methode. Ihr Aufruf blockiert den aktuellen Thread, bis der gestartete Thread beendet ist.
So wird garantiert, dass der gestartete Thread vollständig ausgeführt wird, bevor main fortfährt.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("worker done");
});
handle.join().unwrap();
println!("main done");
}Verschachtelte Ausgabe
Wenn zwei Threads gleichzeitig laufen, kann sich ihre Ausgabe auf unvorhersehbare Weise vermischen. Das Betriebssystem bestimmt die Reihenfolge der Ausführung.
Bei zweimaliger Ausführung desselben Programms können unterschiedliche Reihenfolgen entstehen. Verlassen Sie sich ohne Synchronisierung niemals auf eine bestimmte Reihenfolge.
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();
}Mit sleep pausieren
Sie können einen Thread mit thread::sleep pausieren, das eine Duration entgegennimmt. Dadurch wird die CPU für andere Threads freigegeben, damit diese weiterarbeiten können.
Schlafpausen sind in Beispielen nützlich, um die vermischte Ausgabe sichtbarer zu machen. Für echte Synchronisierung sollten Sie sie jedoch vermeiden.
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));
}Viele Threads starten
Sie können in einer Schleife mehrere Threads starten und ihre Handles in einem Vektor sammeln.
Später durchlaufen Sie den Vektor und rufen für jedes Handle join auf. So wird sichergestellt, dass jeder Thread beendet ist, bevor das Programm endet.
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();
}
}Threads mit Builder benennen
Mit dem Typ thread::Builder können Sie einen Thread vor dem Start konfigurieren. Sie können einen Namen und eine Stackgröße festlegen.
Benannte Threads machen Panic-Meldungen und das Debugging übersichtlicher.
use std::thread;
fn main() {
let h = thread::Builder::new()
.name("worker".into())
.spawn(|| {
println!("running in named thread");
})
.unwrap();
h.join().unwrap();
}Panics bleiben im Thread
Wenn ein gestarteter Thread in eine Panic läuft, stürzt standardmäßig nicht das gesamte Programm ab. Die Panic bleibt auf diesen Thread beschränkt.
Wenn Sie für einen Thread, in dem eine Panic aufgetreten ist, join aufrufen, erhalten Sie ein Err. Dadurch kann der übergeordnete Thread den Fehler erkennen.
use std::thread;
fn main() {
let h = thread::spawn(|| {
panic!("boom");
});
let result = h.join();
println!("joined, is_err = {}", result.is_err());
}Informationen zum aktuellen Thread
Mit thread::current können Sie den laufenden Thread untersuchen. Die Funktion gibt ein Handle zurück, dessen Methode name den optionalen Threadnamen liefert.
Auch der Haupt-Thread ist ein echter Thread und heißt normalerweise main.
use std::thread;
fn main() {
let current = thread::current();
println!("name: {:?}", current.name());
}Werte aus Threads zurückgeben
Die an spawn übergebene Closure kann einen Wert zurückgeben. Dieser Wert ist in Ok verpackt, wenn Sie join aufrufen.
So können Sie auf einfache Weise etwas in einem anderen Thread berechnen und das Ergebnis später auslesen.
use std::thread;
fn main() {
let h = thread::spawn(|| {
let sum: i32 = (1..=10).sum();
sum
});
let total = h.join().unwrap();
println!("total = {}", total);
}Kurze Überprüfung
Testen Sie Ihr Verständnis vom Starten von Threads.
Zusammenfassung
Sie haben gelernt, Threads mit thread::spawn und einer Closure zu starten. Dabei wird ein JoinHandle zurückgegeben.
Der Aufruf von join wartet auf den Abschluss und liefert den Rückgabewert oder eine Panic. Die Ausgabe mehrerer Threads kann sich unvorhersehbar vermischen, und mit Builder können Sie Threads benennen.
Als Nächstes sehen Sie, wie Sie Daten in die gestarteten Threads verschieben.
Häufig gestellte Fragen
Ist die Lektion „Threads erzeugen“ kostenlos?
Ja — der vollständige Text von „Threads erzeugen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Threads erzeugen“?
Führen Sie Code nebenläufig aus. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn Rust Coding zu starten?
Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Threads erzeugen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?
Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Threads erzeugen
- Daten in Threads verschieben
- Mit Arc und Mutex teilen
- Threads verbinden und Ergebnisse sammeln