Nebenläufige Programmierung in Rust
Die sichere und effiziente Handhabung von Nebenläufigkeit ist einer der Zwecke, für die Rust geschaffen wurde, und sie dient hauptsächlich dazu, die Fähigkeit des Servers zu adressieren, hoher Last standzuhalten.
Das Konzept der Nebenläufigkeit bezieht sich auf verschiedene Teile eines Programms, die unabhängig voneinander ausgeführt werden, was leicht mit dem Konzept der Parallelität verwechselt wird; Parallelität betont die "gleichzeitige Ausführung".
Nebenläufigkeit führt oft zu Parallelität.
Dieses Kapitel behandelt Programmierkonzepte und Details im Zusammenhang mit Nebenläufigkeit.
Threads
Ein Thread ist ein Teil eines Programms, das unabhängig ausgeführt wird.
Der Unterschied zwischen einem Thread und einem Prozess besteht darin, dass ein Thread ein Konzept innerhalb eines Programms ist; ein Programm wird häufig innerhalb eines Prozesses ausgeführt.
In einer Umgebung mit einem Betriebssystem werden Prozesse häufig abwechselnd zur Ausführung eingeplant, während Threads vom Programm innerhalb des Prozesses eingeplant werden.
Da Thread-Nebenläufigkeit sehr wahrscheinlich zu Parallelität führt, treten Deadlock- und Verzögerungsfehler, die bei paralleler Ausführung auftreten, häufig in Programmen mit Nebenläufigkeitsmechanismen auf.
Um diese Probleme zu lösen, verwenden viele andere Sprachen (wie Java und C#) spezielle Laufzeitsoftware zur Koordinierung von Ressourcen, aber das verringert zweifellos die Effizienz der Programmausführung erheblich.
C/C++ unterstützen Multithreading auf der untersten Ebene des Betriebssystems, aber die Sprache selbst und ihre Compiler besitzen nicht die Fähigkeit, Parallelitätsfehler zu erkennen und zu vermeiden, was Entwickler stark unter Druck setzt; Entwickler müssen viel Mühe aufwenden, um Fehler zu vermeiden.
Rust ist nicht auf eine Laufzeitumgebung angewiesen, ähnlich wie C/C++.
Aber Rust hat innerhalb der Sprache selbst Mechanismen einschließlich des Ownership-Systems entworfen, um die häufigsten Fehler bereits in der Kompilierungsphase so weit wie möglich zu beseitigen, was andere Sprachen nicht bieten.
Aber das bedeutet nicht, dass wir beim Programmieren sorglos sein können; bis heute sind Probleme, die durch Nebenläufigkeit verursacht werden, im öffentlichen Bereich nicht vollständig gelöst, und Fehler können immer noch auftreten. Seien Sie beim nebenläufigen Programmieren so vorsichtig wie möglich!
In Rust werden neue Threads durch die Funktion std::thread::spawn erstellt:
Beispiel
use std::time::Duration;
fn spawn_function() {
for i in 0..5 {
println!("spawned thread print {}", i);
thread::sleep(Duration::from_millis(1));
}
}
fn main() {
thread::spawn(spawn_function);
for i in 0..3 {
println!("main thread print {}", i);
thread::sleep(Duration::from_millis(1));
}
}
Ausgabe:
main thread print 0 spawned thread print 0 main thread print 1 spawned thread print 1 main thread print 2 spawned thread print 2
Die Reihenfolge dieses Ergebnisses kann sich in manchen Fällen ändern, aber im Allgemeinen wird es so ausgegeben.
Dieses Programm hat einen untergeordneten Thread, der 5 Textzeilen ausgibt, und der Hauptthread gibt 3 Textzeilen aus. Aber offensichtlich endet der erzeugte Thread ebenfalls, wenn der Hauptthread endet, ohne die gesamte Ausgabe abzuschließen.
Der Parameter der Funktion std::thread::spawn ist eine Funktion, die keine Parameter entgegennimmt, aber der obige Ansatz wird nicht empfohlen. Wir können Closures verwenden, um eine Funktion als Argument zu übergeben:
Beispiel
use std::time::Duration;
fn main() {
thread::spawn(|| {
for i in 0..5 {
println!("spawned thread print {}", i);
thread::sleep(Duration::from_millis(1));
}
});
for i in 0..3 {
println!("main thread print {}", i);
thread::sleep(Duration::from_millis(1));
}
}
Eine Closure ist eine anonyme Funktion, die in einer Variablen gespeichert oder als Argument an andere Funktionen übergeben werden kann. Closures entsprechen Lambda-Ausdrücken in Rust und haben das folgende Format:
|参数1, 参数2, ...| -> 返回值类型 {
// 函数体
}
Zum Beispiel:
Beispiel
let inc = |num: i32| -> i32 {
num + 1
};
println!("inc(5) = {}", inc(5));
}
Ausgabe:
inc(5) = 6
Closures können Typdeklarationen weglassen und den automatischen Typinferenzmechanismus von Rust verwenden:
Beispiel
let inc = |num| {
num + 1
};
println!("inc(5) = {}", inc(5));
}
Das Ergebnis ist unverändert.
join-Methode
Beispiel
use std::time::Duration;
fn main() {
let handle = thread::spawn(|| {
for i in 0..5 {
println!("spawned thread print {}", i);
thread::sleep(Duration::from_millis(1));
}
});
for i in 0..3 {
println!("main thread print {}", i);
thread::sleep(Duration::from_millis(1));
}
handle.join().unwrap();
}
Ausgabe:
main thread print 0 spawned thread print 0 spawned thread print 1 main thread print 1 spawned thread print 2 main thread print 2 spawned thread print 3 spawned thread print 4
Die join-Methode bewirkt, dass das Programm erst dann beendet wird, nachdem der untergeordnete Thread fertig ist.
move erzwingt Eigentumsübertragung
Dies ist eine häufig anzutreffende Situation:
Beispiel
fn main() {
let s = "hello";
let handle = thread::spawn(|| {
println!("{}", s);
});
handle.join().unwrap();
}
Der Versuch, die Ressourcen der aktuellen Funktion in einem untergeordneten Thread zu nutzen, ist definitiv falsch! Denn der Ownership-Mechanismus verbietet diese gefährliche Situation; er würde die Gewissheit der Ressourcenzerstörung, die der Ownership-Mechanismus bietet, zunichtemachen. Wir können das move-Schlüsselwort von Closures verwenden, um dies zu handhaben:
Beispiel
fn main() {
let s = "hello";
let handle = thread::spawn(move || {
println!("{}", s);
});
handle.join().unwrap();
}
Nachrichtenübermittlung
Ein Hauptwerkzeug in Rust zur Umsetzung von Nebenläufigkeit mit Nachrichtenübermittlung ist der Kanal, der aus zwei Teilen besteht: einem Sender und einem Empfänger.
std::sync::mpsc enthält die Methoden für die Nachrichtenübermittlung:
Beispiel
use std::sync::mpsc;
fn main() {
let (tx, rx) = mpsc::channel();
thread::spawn(move || {
let val = String::from("hi");
tx.send(val).unwrap();
});
let received = rx.recv().unwrap();
println!("Got: {}", received);
}
Ausgabe:
Got: hi
Der untergeordnete Thread erhielt den Sender tx vom Hauptthread, rief seine send-Methode auf, um einen String zu senden, und dann empfing der Hauptthread ihn über den entsprechenden Empfänger rx.
Weitere Erweiterungen