Multi-Thread-Bash-Skript- und Prozessmanagement in der Befehlszeile

Die Dinge, die Sie mit dem Bash -Skript tun können, sind grenzenlos. Sobald Sie mit der Entwicklung erweiterter Skripte beginnen, werden Sie bald feststellen. Hat Ihr Computer beispielsweise 2 CPU-Threads oder mehr (viele moderne Maschinen haben 8-32 Threads)? Wenn ja, dann profitieren Sie wahrscheinlich von Multi-Thread-Bash-Skripten und Codierung. Lesen Sie weiter und finden Sie heraus, warum!

In diesem Tutorial lernen Sie:

• So implementieren Sie Multi-Thread-Bash-Einzeiler direkt aus der Befehlszeile
• Warum Multi-Thread-Codierung fast immer die Leistung Ihrer Skripte erhöhen kann und wird erhöhen
• Wie Hintergrund- und Vordergrundprozesse funktionieren und wie man Jobwarteschlangen manipuliert

Multi-Thread-Bash-Skript- und Prozessmanagement

Softwareanforderungen und Konventionen verwendet

Softwareanforderungen und Linux -Befehlszeilenkonventionen

Kategorie	Anforderungen, Konventionen oder Softwareversion verwendet
System	Verteilungsunabhängige, bash-Versionsabhängige
Software	Bash -Befehlszeilenschnittstelle (verprügeln)
Konventionen	# - erfordert, dass gegebene Linux -Befehle mit Root -Berechtigungen entweder direkt als Stammbenutzer oder mit Verwendung von ausgeführt werden können sudo Befehl $ - Erfordert, dass die angegebenen Linux-Befehle als regelmäßiger nicht privilegierter Benutzer ausgeführt werden können

Wenn Sie ein Bash -Skript ausführen, verwendet es maximal einen einzelnen CPU -Thread, es sei denn, Sie starten Unterschalen/Threads. Wenn Ihre Maschine über mindestens zwei CPU-Threads verfügt, können Sie CPU-Ressourcen mit Multi-Thread-Scripting in Bash maximal maximalen. Der Grund dafür ist einfach; Sobald ein sekundärer "Thread" (gelesen: Subshell) gestartet wird, kann dieser nachfolgende Thread einen anderen CPU -Thread verwenden (und oft).

Nehmen Sie für einen Moment an, dass Sie eine moderne Maschine mit 8 oder mehr Fäden haben. Können Sie anfangen zu sehen, wie wir Code ausführen könnten - acht parallele Threads gleichzeitig, jeweils auf einem anderen CPU -Thread (oder über alle Threads geteilt) ausgeführt werden - auf diese Weise würde es viel schneller ausgeführt als ein einzelnes Thread Prozess, der auf einem einzelnen CPU-Thread ausgeführt wird (der mit anderen laufenden Prozessen zusammengearbeitet werden kann)? Die realisierten Gewinne hängen ein wenig von dem ab, was ausgeführt wird, aber Gewinne werden es fast immer geben, fast immer!

Aufgeregt? Großartig. Lassen Sie uns darauf eintauchen.

Zuerst müssen wir verstehen, was eine Unterschale ist, wie sie begonnen wird, warum Sie einen verwenden würden und wie sie zur Implementierung von Multi-Thread-Bash-Code verwendet werden kann.

Eine Unterschale ist ein weiterer Bash -Client -Prozess, der von innerhalb der aktuellen ausgeführt/gestartet wurde. Lassen Sie uns etwas einfaches machen und eine aus einer geöffneten Bash -Terminal -Eingabeaufforderung starten:

$ bash $ exit exit $ 

Was ist hier passiert? Zuerst begannen wir eine weitere Bash -Shell (verprügeln) die begann und wiederum eine Eingabeaufforderung ergeben hat ($). Also die zweite $ Im obigen Beispiel befindet sich tatsächlich eine andere Bash -Hülle mit einer anderen PID (PID ist die Prozesskennung; Eine eindeutige Zahlenkennung, die jeden laufenden Prozess in einem Betriebssystem eindeutig identifiziert. Schließlich haben wir durch die Unterschale übergingen Ausfahrt und kehrte zur übergeordneten Unterschale zurück! Können wir irgendwie beweisen, dass dies wirklich das ist, was passiert ist?? Ja:

$ echo $ 220250 $ bash $ echo $ 222629 $ Ausstieg Ausgang $ echo $ 220250 $ 

Es gibt eine spezielle Variable in Bash $$, das enthält die PID der im Gebrauch. Können Sie sehen, wie sich der Prozesskennung verändert hat, sobald wir uns in einer Unterschale befanden?

Großartig! Jetzt, da wir wissen, welche Unterschalen sind und wie sie arbeiten, lassen Sie uns in einige Codierungsbeispiele mit mehreren Threads eintauchen und mehr erfahren!

Einfaches Multi-Threading in Bash

Beginnen wir mit einem einfachen Einweiser-Multi-Thread-Beispiel, von dem die Ausgabe zunächst etwas verwirrend aussehen kann:

$ für i in $ (SEQ 1 2); echo $ i; 1 2 $ für i in $ (SEQ 1 2); do echo $ i & done [1] 223561 1 [2] 223562 $ 2 [1]- Done Echo $ i [2]+ Done Echo $ i $ 

In der ersten für Schleife (siehe unseren Artikel über Bash -Loops, um zu erfahren, wie man Loops codiert
), wir geben einfach die Variable aus $ i die von 1 bis 2 reichen (aufgrund unserer Verwendung des SEQ -Befehls), was interessanterweise in einer Unterschale gestartet wird!

NOTIZ
Du kannst den ... benutzen $ (…) Syntax überall Innerhalb einer Befehlszeile, um eine Unterschale zu starten: Es ist eine sehr leistungsstarke und vielseitige Methode, um Unterschalen direkt in andere Befehlszeilen zu codieren!

In dieser Sekunde für Schleife, wir haben nur einen Charakter verändert. Anstatt zu verwenden ; - Eine EOL (End of Line) Bash -Syntax -Idiom, die einen bestimmten Befehl endet (Sie können darüber nachdenken, wie Eingabetaste/Ausführen/Ausführen/MOS), haben wir verwendet &. Diese einfache Änderung sorgt für ein fast völlig anderes Programm, und unser Code ist jetzt multi-thread! Beide Echo werden mehr oder weniger gleichzeitig verarbeitet, wobei eine geringe Verzögerung im Betriebssystem noch den zweiten Loop -Lauf ausführen muss (um '2' zu echo)).

Sie können darüber nachdenken & in ähnlicher Weise wie ; mit dem Unterschied, das & Wird das Betriebssystem mitteilen, dass er den nächsten Befehl weiter ausführen soll, verarbeiten Sie den Code weiter, während ; Warten auf den aktuellen Befehl ausführend (beendet von ;) um zu kündigen / zu beenden, bevor sie zur Eingabeaufforderung zurückkehren / den nächsten Code weiter verarbeiten und ausführen.

Lassen Sie uns nun die Ausgabe untersuchen. Wir sehen:

[1] 223561 1 [2] 223562 $ 2 

Zuerst gefolgt von:

[1]- erledigte echo $ i [2]+ erledigte echo $ i $ 

Und es gibt auch eine leere Zeile dazwischen, die das Ergebnis von immer noch ausgeführten Hintergrundprozessen ist, während sie auf die nächste Befehlseingabe warten fühle, wie das funktioniert).

Die erste Ausgabe ([1] 223561) zeigt uns, dass ein Hintergrundprozess mit PID gestartet wurde 223561 und die Identifikator -Nummer 1 wurde ihm gegeben. Dann, bereits bevor das Drehbuch das zweite Echo erreichte (ein Echo ist wahrscheinlich eine teure Code -Anweisung), die Ausgabe 1 wurde gezeigt.

Unser Hintergrundvorgang wurde nicht vollständig abgeschlossen, da der nächste Ausgang angibt [2]) mit PID 223562. Anschließend gibt der zweite Prozess die aus 2 („Indikativ“: OS -Mechanismen können dies beeinflussen) bevor der zweite Thread abgeschlossen wird.

Schließlich sehen wir im zweiten Ausgangsblock die beiden Prozesse enden (wie angegeben von Erledigt) sowie was sie zuletzt umführten (wie angegeben von echo $ i). Beachten Sie, dass die gleichen Zahlen 1 und 2 verwendet werden, um die Hintergrundprozesse anzugeben.

Mehr Multi-Threading in Bash

Lassen Sie uns als nächstes drei Schlafbefehle ausführen, die alle von beendet werden & (Deshalb beginnen sie als Hintergrundprozesse) und lassen uns ihre Schlafdauerlängen variieren, sodass wir deutlicher sehen können, wie die Hintergrundverarbeitung funktioniert.

$ Sleep 10 & Sleep 1 & Sleep 5 & [1] 7129 [2] 7130 [3] 7131 $ [2] 

Die Ausgabe sollte in diesem Fall selbsterklärend sein. Die Befehlszeile kehrt sofort nach unserem zurück Schlaf 10 & Schlaf 1 & Schlaf 5 & Befehl und 3 Hintergrundprozesse mit ihren jeweiligen PIDs werden gezeigt. Ich habe ein paar Mal dazwischen eingetragen. Nach 1 Sekunde wurde der erste Befehl abgeschlossen und ergab die Erledigt Für Prozesskennung [2]. Anschließend endete der dritte und erste Prozess nach ihren jeweiligen Schlafdauern. Beachten Sie auch, dass dieses Beispiel deutlich zeigt, dass mehrere Jobs gleichzeitig im Hintergrund effektiv ausgeführt werden.

Möglicherweise haben Sie auch die aufgegriffen + Melden Sie sich in den oben genannten Ausgangsbeispielen an. Hier dreht sich alles um Arbeitskontrolle. Wir werden die Arbeitskontrolle im nächsten Beispiel betrachten, aber im Moment ist es wichtig, das zu verstehen + Zeigt an. Es ist immer der Job, der zu Zuletzt in die Liste der laufenden Jobs hinzugefügt wurde. Dies ist der Standardjob, der immer derjenige ist, der zuletzt in die Liste der Jobs hinzugefügt wurde.

A - Gibt den Job an, der bei der aktuellen Aufgabe der nächste Standard für Jobsteuerungsbefehle werden würde (der Job mit dem + Zeichen) würde enden. Jobkontrolle (oder mit anderen Worten; Hintergrund -Thread -Handhabung) mag zunächst etwas entmutigend klingen, aber es ist tatsächlich sehr praktisch und einfach zu bedienen, sobald Sie sich daran gewöhnt haben. Lassen Sie uns eintauchen!

Jobkontrolle in Bash

$ Sleep 10 & Sleep 5 & [1] 7468 [2] 7469 $ Job 

Hier haben wir zwei Schlaf im Hintergrund gestellt. Sobald sie gestartet wurden, untersuchten wir die derzeit laufenden Jobs mit der Verwendung der Arbeitsplätze Befehl. Als nächstes wurde der zweite Faden in den Vordergrund mit der Verwendung des fg Befehl gefolgt von der Jobnummer. Sie können so darüber nachdenken; Die & im Schlaf 5 Das Kommando wurde in a umgewandelt ;. Mit anderen Worten, ein Hintergrundprozess (nicht darauf gewartet) wurde ein Vordergrundprozess.

Wir haben dann auf die gewartet Schlaf 5 Befehl zur Fertigstellung und anschließend platzierte die Schlaf 10 Befehl in den Vordergrund. Beachten Sie, dass wir jedes Mal, wenn wir dies taten, warten mussten, bis der Vordergrundvorgang fertig ist, bevor wir unsere Befehlszeile zurückerhalten, was bei Verwendung von nur Hintergrundprozessen nicht der Fall ist (da sie buchstäblich im Hintergrund laufen).

Jobkontrolle in Bash: Jobunterbrechung

$ schlaf 10 ^z [1]+ gestoppt schlaf 10 $ bg 1 [1]+ schlaf 10 & $ fg 1 schlaf 10 $ 

Hier drücken wir Strg+Z, um einen laufenden Schlaf 10 zu unterbrechen (was abgebrochen wird, wie angegeben von Gestoppt). Anschließend legen wir den Vorgang in den Hintergrund und stellten ihn schließlich in den Vordergrund und warten darauf, dass er fertig ist.

Jobkontrolle in Bash: Jobunterbrechung

$ Sleep 100 ^Z [1]+ Störungen Schlaf 100 $ Kill %1 $ [1]+ Beendigte Schlaf 100 

Nachdem er 100 Sekunden begonnen hatte schlafen, Als nächstes unterbrechen wir den Laufprozess durch Strg+Z und töten dann den ersten Start/Running -Hintergrundprozess durch die Verwendung des töten Befehl. Beachten Sie, wie wir verwenden %1 in diesem Fall statt einfach 1. Dies liegt daran, dass wir jetzt mit einem Dienstprogramm arbeiten, das nicht nativ mit Hintergrundprozessen gebunden ist fg Und BG Sind. Um anzuzeigen, um zu töten, dass wir den ersten Hintergrundprozess bewirken wollen, verwenden wir % gefolgt von der Hintergrundprozessnummer.

Jobkontrolle in Bash: Prozess abgelehnt

$ Sleep 100 ^Z [1]+ STORD SLEEP 100 $ BG %1 [1]+ Schlaf 100 & $ disuner 

In diesem letzten Beispiel beenden wir erneut einen Lauf schlafen, und legen Sie es in den Hintergrund. Endlich führen wir die aus verleugnen Befehl, den Sie lesen können als: alle Hintergrundprozesse (Jobs) aus der aktuellen Shell abbauen. Sie werden weiter laufen, sind aber nicht mehr im Besitz der aktuellen Hülle. Auch wenn Sie Ihre aktuelle Hülle und Ihr Anmelden schließen, werden diese Prozesse weiter ausgeführt, bis sie auf natürliche Weise enden.

Dies ist eine sehr leistungsstarke Methode, um einen Prozess zu unterbrechen, ihn in den Hintergrund zu legen, ihn abzulehnen und sich dann von der von Ihnen verwendeten Maschine anzumelden, vorausgesetzt, Sie müssen nicht mehr mit dem Prozess interagieren. Ideal für diese lang laufenden Prozesse über SSH, die nicht unterbrochen werden können. Einfach Strg+z den Prozess (der ihn vorübergehend unterbricht), in den Hintergrund legen, alle Jobs verleugnen und abmelden! Gehen Sie nach Hause und haben Sie einen schönen entspannten Abend, wenn Sie wissen, dass Ihre Arbeit weiter läuft!

Multi-Thread-Bash Scripting & Process Management Command Line Beispiele

Abschluss

In diesem Tutorial haben wir gesehen. Wir haben auch untersucht, wie Hintergrund- und Vordergrundprozesse funktionieren, und wir manipulierten Jobwarteschlangen. Schließlich haben wir untersucht. Genießen Sie Ihre neu gefundenen Fähigkeiten und hinterlassen Sie uns unten einen Kommentar zu Ihren Arbeitskontrollerfahrungen!

Verwandte Linux -Tutorials:

• Eine Einführung in Linux -Automatisierung, Tools und Techniken
• Dinge zu installieren auf Ubuntu 20.04
• Dinge zu tun nach der Installation Ubuntu 20.04 fokale Fossa Linux
• Mastering -Bash -Skriptschleifen beherrschen
• Bash -Hintergrundprozessmanagement verleihen
• Verschachtelte Schleifen in Bash -Skripten
• Ubuntu 20.04 Leitfaden
• Dinge zu tun nach der Installation Ubuntu 22.04 Jammy Quallen…
• Tipps und Trick -Beispiele für nützliche Bash -Bash -Befehlszeilen - Teil 6
• GDB -Debugging -Tutorial für Anfänger