Python Multiprocessing Lock

Das Multiprocessing -Paket von Python ermöglicht es den Benutzern, neue Prozesse zu erstellen und auf die Python -API zuzugreifen. Wenn Sie jemals mit dem Threading -Modul herumgespielt haben, ist dies sehr vergleichbar. Mehrere Aufgabenleistung ist erforderlich. Wir müssen das Multiprocessing -Modul in das Python -Skript importieren, um Multiprocessing -Operationen durchzuführen. Wenn zwei Prozesse oder Threads versuchen, auf eine gemeinsame Ressource wie Speicherdateien oder andere Daten zuzugreifen, kann dies zu Problemen in der Programmierwelt führen. Daher müssen wir diesen Zugriff mit einem Schloss sichern. Durch das Teilen des Hauptspeichers und des Zubehörs können die Verarbeitungseinheiten die Programme gleichzeitig ausführen.

Die Multiprozessierungsanwendung unterteilt sich in kleinere Einheiten und arbeitet separat. Das Betriebssystem weist jedem Prozess einen Prozessor zu. Um zu verhindern, dass ein anderer Prozess eine äquivalente Funktion ausführt, bis die Sperre freigelassen ist. Die Schlossklasse erfüllt in erster Linie zwei Funktionen. Mit der Methode Accire () wird zuerst ein Schloss erhalten.

Pythons Implementierung des Lock () in Multiprocessing

In diesem Beispiel konstruieren wir ein Sperre und verwenden dann das Multiprocessing -Modul, um die Lock () -Methode nach dem Erstellen von zwei Prozessen zu verwenden. Wir können die neuen Kinderaufgaben in Python erstellen und pflegen, indem wir das Multiprozessing -Paket verwenden. Die Multiprocessing -Komponente erleichtert das Erstellen der Prozesse mithilfe einer Schnittstelle, die der Threading -Komponente ähnelt. Das Multiprocessing -Modul unterstützt eher lokale als auch globale Parallelität mit einzelnen Teilen und nicht mit Fäden, wodurch die globale Interpretationsschloss beseitigt. Python hat eine Mutex -Sperre, die mit mehreren Prozessen gleichzeitig verwendet werden kann.Klassenschloss. Prozesse können ein Objekt der Verriegelung erstellen, erwerben und dann freigeben, bevor er auf einen wichtigen Bereich zugreift.

Lassen Sie uns nun den Code implementieren, um das Python -Multiprocessing -Skript auszuführen. "Spyder" wird ebenfalls verwendet. Wir importieren zuerst das Multiprocessing -Modul. Wir müssen das Multiprocessing -Modul importieren, da wir einen Prozess im Skript erstellen müssen. Danach erstellen wir eine benutzerdefinierte Funktion namens "Funktion" und übergeben das "Sperren" -Argument in der folgenden Zeile. Die Erwerbsmethode wird dann mit der "Sperren" -Phrase aufgerufen, die eine Thread -Autorität über einer Sperre liefert. Ein Faden blockiert, bis der andere Faden das Schloss fallen lässt, wenn er versucht, einen zu erwerben, der bereits von einem anderen Faden gehalten wird. In diesem Moment konkurriert es mit jedem anderen Thread, der versucht, das Schloss zu beschlagnahmen. Ein Faden zu dem anderen kann nur das Schloss besitzen. Die Anweisung "Wichtige Abschnitt" wird dann als Eingabe als Eingabe übergeben, wenn wir in der folgenden Schritt den "print ()" aufrufen.

Im nachfolgenden Schritt nennen wir dann noch einmal die Funktion „print ()“ und übergeben sie den Ausdruck "Es kann jeweils nur einen Prozess vorhanden sein", bevor wir die Funktion „Release ()“ mit der „Sperre“ aufrufen, wenn sie aufrufen. Wenn dies auf diese Weise durchgeführt wird, wird das Schloss immer freigegeben, auch wenn im entscheidenden Bereich ein Fehler oder Fehler vorhanden ist, und definiert deutlich den Beginn und das Ende des geschützten Code.

Nachdem wir eine Funktion mit dem Namen „Funktionslauf“ definiert haben, fahren wir mit der nächsten Phase fort, in der wir einen Prozess erstellen und ihn dann mit dem Modul „Lock ()“ aufrufen. Wir halten es im Sperrparameter und verwenden „Multiprozessierung.lock () “, um das Schloss mit dem Vorgang anzurufen. Nachdem wir Prozess 1 erstellt haben, verwenden wir „Multiprocessing.Prozess “, um die Funktion in diesem Prozess aufzurufen. Wir übergeben auch die Argumentschloss an die Funktion mit der "argu" = "lock" und speichern den Prozess 1 in der Variablen „P1“.

Dann verwenden wir im folgenden Schritt „Multiprocessing.Prozess “, um die Funktion in Prozess 2 auszuführen und die Funktion" target = function "zu übergeben, während sie in der Variablen„ P2 “gespeichert wird. Der Prozess wird dann mit der Funktion „start ()“ mit „p1“ und „p2“ begonnen. Im nächsten Schritt verwenden wir "Join ()" mit "P1" und "P2", um zu warten, bis die Prozessausführung fertiggestellt ist. Als nächstes verwenden wir den "if name = main_", der im Wesentlichen ein Eingangspunkt ist. Die "Funktion run ()" wird dann am Ende aufgerufen.

Um dies zu erreichen, muss der Prozess zuerst das Schloss erwerben, bevor er den wesentlichen Teil ausführt. Wenn die kritische Phase der Aufgabe abgeschlossen ist, muss der Vorgang die Sperre entfernen. Sowohl die beiden Prozesse als auch ihre Aussagen wurden angezeigt. Es konnte nur eine einzige Aufgabe geben, die zu einem Zeitpunkt ausgeführt wurde, der nach dem „kritischen Abschnitt“ vorgestellt wurde.”

Wir haben jetzt ein weiteres Beispiel für Python Multiprocessing Lock. Beginnen wir mit dem Importieren von „Schlaf“ aus dem Zeitmodul, bevor wir „zufällig“ aus dem Zufallsmodul importieren. Ganzzahlen werden zufällig unter Verwendung eines Python -Programms namens Python Random generiert. Da sie Pseudo-Random sind, sind diese Zahlen nicht wirklich zufällig. Sie können dieses Paket verwenden, um andere zufällige Operationen auszuführen, eine Zufallszahl für eine Liste oder eine String zu drucken und die Zufallszahlen zu generieren.

Als nächstes importieren wir den Prozess aus der Multiprozesation in der folgenden Zeile. Das Schloss wird dann aus der Multiprozessierung importiert. Die Funktion "func" wird dann mit den Argumenten "Sperre", "Identifier" und "Val" definiert. Als nächstes verwenden wir ein Schloss, um das Schloss zu erhalten. Dieser entscheidende Teil beinhaltet die Berichterstattung über eine Nachricht und das Blockieren einer zweiten Nachricht.

Infolgedessen führen wir die Print () -Methode innerhalb der Sperre aus und übergeben die Anweisung zusammen mit den Aufrufen „Kennung“ und „Val“. Die Methode „Sleep ()“ wird verwendet, um die Ausführung für eine festgelegte Anzahl von Sekunden zu pausieren. Wir nennen dann "Val" in seinen Klammern. Das gemeinsame Sperre wird mit der Methode „Lock ()“ festgelegt und in der neu erstellten "Sperre" -Variable gespeichert, wenn wir die Bedingung "if name = main_" verwenden. Als nächstes verwenden wir die Process () -Methode, um einen Prozess zu erstellen und das „target = func“ zu übergeben, um die Funktion zusammen mit dem Argument „Sperre“, der konstruierten Nummer „X“ und dem „Random ()“ in den Prozess aufzurufen, und das „Random ()“ “. Funktion. Diese Schleife endet nach Abschluss seiner „15“ Iterationen. Wir speichern diesen Prozess in der Variablen „P“.

Hier stellen wir auch den Bereich mit „für“ fest und setzen den Bereich auf „15“,. Der Prozess beginnt jetzt mit dem Aufrufen des Prozesses.Start()". Dann nennen wir den Prozess mit der Methode „Join ()“, um auf die Ausführung zu warten.

Wenn das Beispiel ausgeführt wird, werden fünfzehn Prozesse gestartet, und jeder ist so konfiguriert, dass sie unsere benutzerdefinierte Funktion verwenden. Danach wartet der Hauptprozess darauf, dass jedes der Kinderprozesse vor dem Start abgeschlossen ist. Jeder untergeordnete Prozess in der Funktion (Function () -Methode versucht, das Schloss zu greifen. Das Schloss kann jeweils nur durch einen Prozess erhalten werden. In diesem Fall senden sie eine Nachricht mit ihrer Identität und wie lange sie schlafen möchten, und der Index ist nicht in Ordnung, da sie in der Ausgabe angezeigt wird, sobald der Betrieb abgeschlossen ist.

Abschluss

Wir haben in diesem Artikel etwas über das Python -Multiprocessing -Sperre gelernt. Das Schloss ist ein grundlegendes Konzept für die Multiprozessierungs- und Betriebssystemtheorie. Im ersten Abschnitt des Beispiels haben wir zwei Prozesse mithilfe einer Schloss erstellt und sie mit einer Schloss aufgerufen, um die von uns definierte Funktion auszuführen. Im folgenden Abschnitt des Codes haben wir den For-Loop verwendet und den Bereich auf „15“ festgelegt, um den Prozess auszuführen. Der Prozess wird beendet, sobald er seine „15“ Iterationen abgeschlossen hat. Im zweiten Abschnitt haben wir auch die „Sleep ()“ -Technik verwendet, um die Ausführung für kurze Zeit zu verzögern.