Das wichtigste Element der Datenstruktur ist die Warteschlange. Vergleichbar ist die „first in, first out“-Datenstruktur-Warteschlange, die die Grundlage für Python-Multiprocessing bildet. Der Prozessfunktion werden Warteschlangen bereitgestellt, damit der Prozess die Daten erfassen kann. Das erste Datenelement, das aus der Warteschlange eliminiert wird, ist das erste Element, das eingegeben wird. Wir verwenden die „put()“-Methode der Warteschlange, um die Daten zur Warteschlange hinzuzufügen, und ihre „get()“-Methode, um die Daten aus der Warteschlange abzurufen.
Beispiel 1: Verwenden der Queue()-Methode zum Erstellen einer Multiprocessing-Warteschlange in Python
In diesem Beispiel erstellen wir eine Multiprocessing-Warteschlange in Python mit der Methode „queue()“. Multiprocessing bezieht sich auf die Verwendung einer oder mehrerer CPUs in einem System, um zwei oder mehr Prozesse gleichzeitig auszuführen. Multiprocessing, ein konstruiertes Modul in Python, erleichtert das Umschalten zwischen Prozessen. Wir müssen mit der Prozesseigenschaft vertraut sein, bevor wir mit Multiprocessing arbeiten. Wir sind uns bewusst, dass die Warteschlange eine entscheidende Komponente des Datenmodells ist. Die Standard-Datenwarteschlange, die auf der „First-In-First-Out“-Idee aufgebaut ist, und Python-Multiprocessing sind genaue Gegenstücke. Im Allgemeinen speichert die Warteschlange das Python-Objekt und ist entscheidend für die Datenübertragung zwischen Aufgaben.
Das Tool „Spyder“ wird verwendet, um das vorhandene Python-Skript zu implementieren, also fangen wir einfach an. Wir müssen zuerst das Multiprocessing-Modul importieren, da wir das Python-Multiprocessing-Skript ausführen. Dazu haben wir das Multiprocessing-Modul als 'm' importiert. Unter Verwendung der „m.queue()“-Technik rufen wir die Multiprocessing-Methode „queue()“ auf. Hier erstellen wir eine Variable namens „queue“ und platzieren die Multiprocessing-Methode „queue()“ darin. Da wir wissen, dass die Warteschlange Elemente in einer „first-in, first-out“-Reihenfolge speichert, wird das Element, das wir zuerst hinzufügen, zuerst entfernt. Nach dem Start der Multiprocessing-Warteschlange rufen wir dann die Methode „print()“ auf und übergeben die Anweisung „There is a multiprocessing queue“ als Argument, um sie auf dem Bildschirm anzuzeigen. Da wir die konstruierte Warteschlange in dieser Variablen speichern, drucken wir die Warteschlange, indem wir die Variable „queue“ in der Klammer der Methode „print()“ übergeben.
Das folgende Bild zeigt, dass die Python-Multiprocessing-Warteschlange jetzt erstellt wurde. Die gedruckte Anweisung wird zuerst angezeigt. Nachdem diese Multiprocessing-Warteschlange an der bezeichneten Speicheradresse erstellt wurde, kann sie verwendet werden, um die unterschiedlichen Daten zwischen zwei oder mehr laufenden Prozessen zu übertragen.
Beispiel 2: Verwendung der Methode „Qsize()“ zur Bestimmung der Größe der Multiprocessing-Warteschlange in Python
In diesem Fall bestimmen wir die Größe der Multiprocessing-Warteschlange. Um die Größe der Multiprocessing-Warteschlange zu berechnen, verwenden wir die Methode „qsize()“. Die Funktion „qsize()“ gibt die tatsächliche Größe der Python-Multiprocessing-Warteschlange zurück. Mit anderen Worten, diese Methode liefert die Gesamtzahl der Elemente in einer Warteschlange.
Beginnen wir damit, das Python-Multiprocessing-Modul als „m“ zu importieren, bevor wir den Code ausführen. Dann rufen wir mit dem Befehl „m.queue()“ die Multiprocessing-Funktion „queue()“ auf und schreiben das Ergebnis in die Variable „Queue“. Dann fügen wir die Items mit der „put()“-Methode in die Warteschlange in der folgenden Zeile ein. Diese Methode wird verwendet, um die Daten einer Warteschlange hinzuzufügen. Daher rufen wir „Queue“ mit der „put()“-Methode auf und liefern die Integer-Zahlen als sein Element in seiner Klammer. Die Zahlen, die wir hinzufügen, sind „1“, „2“, „3“, „4“, „5“, „6“ und „7“, indem wir die „put()“-Funktionen verwenden.
Außerdem rufen wir unter Verwendung von „Queue“, um die Größe der Multiprocessing-Warteschlange zu erhalten, „qsize()“ mit der Multiprocessing-Warteschlange auf. Dann speichern wir in der neu gebildeten Variable „Ergebnis“ das Ergebnis der Methode „qsize()“. Danach rufen wir die Methode „print()“ auf und übergeben als Parameter die Anweisung „The multiprocessing queue’s size is“. Als nächstes rufen wir die „result“-Variable in der „print()“-Funktion auf, da die Größe in dieser Variable gespeichert wird.
Das Ausgabebild hat die angezeigte Größe. Da wir die Funktion „put()“ verwenden, um sieben Elemente zur Multiprocessing-Warteschlange hinzuzufügen, und die Funktion „qsize()“, um die Größe zu bestimmen, wird die Größe „7“ der Multiprocessing-Warteschlange angezeigt. Die Eingabeanweisung „die Größe der Multiprocessing-Warteschlange“ wird vor der Größe angezeigt.
Beispiel 3: Verwenden der Methoden „Put()“ und „Get()“ in der Python-Multiprocessing-Warteschlange
In diesem Beispiel werden die Queue-Methoden „put()“ und „get()“ aus der Python-Multiprocessing-Queue verwendet. In diesem Beispiel entwickeln wir zwei benutzerdefinierte Funktionen. In diesem Beispiel definieren wir eine Funktion, um einen Prozess zu erstellen, der „5“ zufällige ganze Zahlen erzeugt. Wir verwenden auch die Methode „put()“, um sie einer Warteschlange hinzuzufügen. Die Methode „put()“ wird verwendet, um die Elemente in die Warteschlange zu stellen. Um dann die Zahlen aus der Warteschlange abzurufen und ihre Werte zurückzugeben, schreiben wir eine weitere Funktion und rufen sie während der Prozedur auf. Wir verwenden die Funktion „get()“, um die Zahlen aus der Warteschlange abzurufen, da diese Methode verwendet wird, um die Daten aus der Warteschlange abzurufen, die wir mit der Methode „put()“ einfügen.
Beginnen wir jetzt mit der Implementierung des Codes. Zuerst importieren wir die vier Bibliotheken, aus denen dieses Skript besteht. Wir importieren zuerst „sleep“ aus dem time-Modul, um die Ausführung für einige in Sekunden gemessene Zeit zu verzögern, gefolgt von „random“ aus dem random-Modul, das zum Generieren von Zufallszahlen verwendet wird, und dann „process“ aus Multiprocessing, da dieser Code einen Prozess erstellt , und schließlich die „Warteschlange“ von Multiprocessing. Durch den anfänglichen Aufbau einer Klasseninstanz kann die Warteschlange verwendet werden. Standardmäßig wird dadurch eine unendliche Warteschlange oder eine Warteschlange ohne maximale Größe eingerichtet. Indem Sie die Option „Max. Größe“ auf eine Zahl größer als Null setzen, ist es möglich, eine Kreation mit einer Größenbeschränkung zu erstellen.
Wir definieren eine Funktion. Da diese Funktion benutzerdefiniert ist, geben wir ihr dann den Namen „Funktion1“ und übergeben den Begriff „Warteschlange“ als Argument. Anschließend rufen wir die Funktion „print()“ auf und übergeben ihr die Anweisungen „builder: Running“, „flush“ und das Objekt „True“. Die Druckfunktion von Python hat eine einzigartige Option namens flush, mit der der Benutzer wählen kann, ob diese Ausgabe gepuffert werden soll oder nicht. Der nächste Schritt besteht darin, die Aufgabe zu generieren. Dazu verwenden wir „for“, erstellen die Variable „m“ und setzen den Bereich auf „5“. Verwenden Sie dann in der nächsten Zeile „random()“ und speichern Sie das Ergebnis in der von uns erstellten Variablen „value“. Dies zeigt an, dass die Funktion nun ihre fünf Iterationen beendet, wobei jede Iteration eine zufällige Ganzzahl von 0 bis 5 erstellt.
Dann rufen wir im nächsten Schritt die Funktion „sleep()“ auf und übergeben das Argument „value“, um den Teil um eine bestimmte Anzahl von Sekunden zu verzögern. Dann rufen wir die „Warteschlange“ mit der Methode „put()“ auf, um den Wert im Wesentlichen zur Warteschlange hinzuzufügen. Anschließend wird der Benutzer durch einen erneuten Aufruf der Methode „queue.put()“ und die Übergabe des Werts „None“ darüber informiert, dass keine weiteren Arbeiten zu erledigen sind. Dann führen wir die Methode „print()“ aus, übergeben die Anweisung „builder: ready“ zusammen mit „flush“ und setzen sie auf „true“.
Wir definieren nun eine zweite Funktion „function2“ und weisen ihr als Argument das Schlüsselwort „queue“ zu. Dann rufen wir die Funktion „print()“ auf, während wir die Berichtszustände „User: Running“ und „flush“ übergeben, die auf „True“ gesetzt sind. Wir starten die Operation von „function2“ mit der While-True-Bedingung, um die Daten aus der Warteschlange zu nehmen und in die neu erstellte „item“-Variable zu schreiben. Dann verwenden wir die „if“-Bedingung, „item is none“, um die Schleife zu unterbrechen, wenn die Bedingung wahr ist. Wenn kein Element verfügbar ist, hält es an und fragt den Benutzer nach einem. Die Aufgabe stoppt die Schleife und endet in diesem Fall, wenn das Element, das aus dem Wert erhalten wird, null ist. Dann rufen wir im nächsten Schritt die Funktion „print()“ auf und stellen ihr den Report „User: ready“ und die Parameter „flush=True“ zur Verfügung.
Dann betreten wir den Hauptprozess mit „If-name = main_“. Wir erstellen eine Warteschlange, indem wir die Methode „queue()“ aufrufen und in der Variablen „queue“ speichern. Als nächstes erstellen wir einen Prozess, indem wir die Benutzerfunktion „Funktion2“ aufrufen. Dafür nennen wir die Klasse „Prozess“. Darin übergeben wir „target=function2“, um die Funktion im Prozess aufzurufen, übergeben das Argument „queue“ und speichern es in der Variable „User_process“. Der Prozess beginnt dann mit dem Aufruf der Methode „start()“ mit der Variable „User_ process“. Wir wiederholen dann das gleiche Verfahren, um die „Funktion1“ im Prozess aufzurufen und in die Variable „Builder-Prozess“ einzufügen. Dann rufen wir die Prozesse mit der Methode „join()“ auf, um auf die Ausführung zu warten.
Jetzt, da es präsentiert wird, können Sie die Anweisungen beider Funktionen in der Ausgabe sehen. Es zeigt die Elemente an, die wir mit „put()“ und „get()“ hinzugefügt haben, indem wir die „get()“-Methoden verwenden.
Fazit
Wir haben in diesem Artikel etwas über die Python-Multiprocessing-Warteschlange gelernt. Wir haben die angegebenen Illustrationen verwendet. Zuerst haben wir beschrieben, wie Sie mit der Funktion queue() eine Warteschlange in Python Multiprocessing erstellen. Anschließend haben wir die Methode „qsize()“ verwendet, um die . Wir haben auch die Methoden put() und get() der Warteschlange verwendet. Die Schlafklasse des Zeitmoduls und die Zufallsklasse des Zufallsmoduls wurden beide im letzten Beispiel diskutiert.