Rostzubehör

Parallelität bezieht sich auf eine Funktion, mit der eigenständige Teile eines Programms parallel zu anderen Abschnitten des Code ausgeführt werden können. Die Parallelität ermöglicht es verschiedenen Teilen eines Programms, gleichzeitig auszuführen und die Leistung zu verbessern.

Lassen Sie uns in der Rost -Programmiersprache durch den Wald der Parallelitätsprogrammierung spazieren gehen. Denken Sie daran, dass dieser Artikel nicht als vollständig. Es dient nur als Grundlage für die Erweiterung und Erstellung komplexerer Anwendungen.

Prozesse und Fäden

Wenn wir ein normales Programm schreiben und es auf einem Zielsystem ausführen, führt das Host -Betriebssystem den Code in einem Prozess aus. Ein Prozess bezieht sich auf eine Einheit einer angegebenen ausführbaren Datei.

In modernen Systemen und Anwendungen haben Sie jedoch Teile desselben Codes gleichzeitig mit Threads ausgeführt.

In den meisten Fällen hören Sie häufig den verwendeten Begriff Multi-Threading, bei dem Parallelität auftritt. Dies liegt daran.

Nehmen wir ein grundlegendes Programm auf, um zu veranschaulichen, wie ein normales Programm funktioniert und wie die Parallelität verwendet wird, um es zu verbessern.

Betrachten Sie ein Programm mit zwei Schleifen wie gezeigt:

Verwenden Sie std :: thread;
Verwenden Sie STD :: TIME :: Dauer;
fn main ()
für i in 0… = 5
println!("", ich);
// für 1000 ms schlafen
Thread :: Sleep (Dauer :: von_Millis (1000));

für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (1000));

Im obigen Beispielcode haben wir zwei Schleifen, die von 0 bis 5 iterieren. In jeder Iteration schlafen wir jedoch 1000 Millisekunden.

Die Thread :: Sleep -Methode ermöglicht es uns, einen bestimmten Faden für die angegebene Dauer in den Schlaf zu setzen.

Wenn Sie den obigen Code ausführen, stellen Sie fest, dass die erste Schleife auf die zweite Schleife wartet, bevor er ausgeführt werden kann.

Dies liegt daran, dass beide Loops auf einem einzigen Thread liegen.

Wenn wir möchten, dass beide Loops gleichzeitig laufen, müssen wir sie in verschiedene Fäden einsetzen.

Rost erstellen Faden

Mit dem Thread -Modul können wir neue Threads erstellen. Es ist Teil der Standardbibliothek und bietet uns eine Reihe von Tools und Funktionen für die Arbeit mit Threads.

Wir können es mit der Anweisung importieren:

Verwenden Sie STD :: Thread;

Wir brauchen auch das Dauermodul aus dem Zeit Thread. Wir können es importieren wie:

Verwenden Sie STD :: TIME :: Dauer

Um einen neuen Thread in Rost zu erstellen, verwenden Sie die Thread :: Spawn -Methode. Diese Methode nimmt einen Verschluss als Argument.

Der Verschluss definiert in diesem Fall den Code, der im Thread ausgeführt wird.

Die Syntax ist wie unten gezeigt:

Thread :: Spawn (|| Verschluss)

Lassen Sie uns den vorherigen Code verfeinern und jedes Konstrukt in einen separaten Thread einfügen. Beispielcode ist wie gezeigt:

Verwenden Sie std :: thread;
Verwenden Sie STD :: TIME :: Dauer;
fn main ()
// Neuen Thread erstellen
std :: thread :: Spawn (Bewegung ||
für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (1000));

);
für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (1000));

Im obigen Beispielprogramm erstellen wir einen neuen Thread mit der Thread :: Spawn -Funktion und übergeben die erste Schleife als Verschluss.

Im Hauptfaden führen wir die zweite Schleife aus. Dadurch können beide Schleifen gleichzeitig ausgeführt werden. Der obige Code sollte die Ausgabe als:

0
0
1
1
2
2
3
3
4
4
5
5

Was passiert, wenn der Haupt -Thread vor dem Abschluss des „inneren“ Threads verlässt? Ein Beispiel ist wie unten gezeigt:

Verwenden Sie std :: thread;
Verwenden Sie STD :: TIME :: Dauer;
fn main ()
// innerer Thread
std :: thread :: Spawn (Bewegung ||
für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (1000));

);
// hauptsächlich
für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (2));

In diesem Beispiel dauert der Hauptfaden weniger zum Schlafen und wird daher schneller abgeschlossen, bevor der innere Thread abgeschlossen ist.

In einem solchen Fall wird der innere Thread nur ausgeführt, während der Hauptfaden ausgeführt wird. Der obige Code gibt eine unvollständige Ausgabe zurück als:

0
0
1
2
3
4
5

Dies liegt daran, dass der „innere“ Thread vor Fertigstellung gekündigt wird.

Rost -Join -Griffe

Wir haben gesehen, wie sich ein Thread verhält, wenn der Hauptfaden vor dem Abschluss beendet ist. Wir können uns den beiden Griffen anschließen, um einen solchen Fall zu lösen und den anderen Thread auf einen anderen warten zu.

Mit dem Verbindungsgriff können der Hauptfaden vor der Beendigung auf die anderen Fäden warten.

Um Griffe zu verbinden, verwenden wir die Join -Methode wie in der folgenden Syntax:

Sei handle_name = thread :: spawn (closeure);
Handle_Name.verbinden().auspacken();

Lassen Sie uns unser Schleifenbeispiel neu definieren, bei dem der Hauptfaden früh austritt.

Verwenden Sie std :: thread;
Verwenden Sie STD :: TIME :: Dauer;
fn main ()
Handle = Std :: Thread :: Spawn (Bewegung ||
für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (1000));

);
für i in 0… = 5
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (2));

// Join Handle
handhaben.verbinden().auspacken();

Im obigen Beispielcode erstellen wir eine Handle -Variable, die den Thread enthält. Anschließend verbinden wir den Thread mit der moje () -Methode.

Die Ausweichmethode ermöglicht es uns, Fehler zu behandeln.

Da der Hauptfaden für eine kürzere Zeit schläft, sollte er vor dem „inneren“ Faden abgeschlossen sein. Es sollte jedoch darauf warten, dass der andere Thread aufgrund der Join -Methode beendet wird.

Der Ausgang ist wie gezeigt:

0
0
1
2
3
4
5
1
2
3
4
5

Beachten Sie, dass der Hauptfaden alle Werte in kurzer Dauer ausgibt und darauf wartet, dass der andere Faden abgeschlossen ist.

Rost -Fadenschaltung Abschluss

Möglicherweise haben Sie das Keyword in Move Move in dem Thread -Verschluss in unserem vorherigen Beispiel bemerkt. Der MOVE -Verschluss wird mit der Thread :: Spawn -Methode verwendet, um die Teilen von Daten zwischen Threads zu ermöglichen.

Mit dem Schlüsselwort des Verschiebens können wir einem Thread zulassen, den Eigentum an Werten in einen anderen Thread zu übertragen.

Nehmen Sie unten ein Beispielprogramm:

Verwenden Sie std :: thread;
Verwenden Sie STD :: TIME :: Dauer;
fn main ()
Sei arr = [1,2,3,4,5];
Handle = std :: thread :: spawn (||
denn ich in arr.iter ()
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (100));

);
handhaben.verbinden().auspacken();

Im obigen Code deklarieren wir ein Array namens arr im Haupt -Thread. Wir erzeugen dann einen neuen Faden ohne den Verschluss der Bewegung.

Hinweis: Da wir versuchen, auf das Array -ARR zuzugreifen und sie Teil der Schließumgebung zu machen, fällt die Zusammenstellung aus, da sie in diesem Thread nicht verfügbar ist.

Wir können das Move -Schlüsselwort verwenden, um die Schließung im Thread zu erzwingen, um das Array zu übernehmen.

Wir können den obigen Code beheben, indem wir den Move -Verschluss wie gezeigt hinzufügen:

Verwenden Sie std :: thread;
Verwenden Sie STD :: TIME :: Dauer;
fn main ()
Sei arr = [1,2,3,4,5];
Handle = Std :: Thread :: Spawn (Bewegung ||
denn ich in arr.iter ()
println!("", ich);
Thread :: Sleep (Dauer :: von_Millis (100));

);
handhaben.verbinden().auspacken();

Dadurch kann der Thread das Array übernehmen und es iterieren. Dies sollte zurückkehren:

1
2
3
4
5

Abschluss

Das waren die Grundlagen der gleichzeitigen Programmierung in der Rost -Programmiersprache. Obwohl dieser Artikel als konkrete Grundlage für Rost -Parallelität dient, behandelt er keine fortgeschrittenen Konzepte. Sie können die Dokumentation für Details überprüfen.