Python Multiprocessing -Warteschlange

Das wichtigste Element der Datenstruktur ist die Warteschlange. Die Datenstruktur -Warteschlange „First In, First Out“, die die Grundlage für die Python -Multiprozessierung ist, ist vergleichbar. Warteschlangen werden der Prozessfunktion zur Verfügung gestellt, damit der Prozess die Daten erfasst werden kann. Das erste Datenelement, das aus der Warteschlange beseitigt wird. Wir verwenden die "Put ()" -Methode der Warteschlange, um die Daten zur Warteschlange und der "get ()" -Methode hinzuzufügen, um die Daten aus der Warteschlange abzurufen.

Beispiel 1: Verwenden der Queue () -Methode zum Erstellen einer Multiprozesationswarteschlange in Python

In diesem Beispiel erstellen wir in Python eine multiprozessierende Warteschlange mit der Methode "Queue ()". Multiprozessierung bezieht sich auf die Verwendung eines oder mehrerer CPUs in einem System, um zwei oder mehr Prozesse gleichzeitig durchzuführen. Multiprocessing, ein konstruiertes Modul in Python, erleichtert das Umschalten zwischen den 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 Standarddatenwarteschlange, die auf der Idee „Erst in erstmals“ basiert, und die Python-Multiprocessing sind genaue Gegenstücke. Im Allgemeinen speichert die Warteschlange das Python -Objekt und ist für die Datenübertragung zwischen Aufgaben von entscheidender Bedeutung.

Das "Spyder" -Tool wird verwendet, um das vorhandene Python -Skript zu implementieren. Lassen Sie uns also einfach loslegen. Wir müssen zuerst das Multiprocessing -Modul importieren, da wir das Python -Multiprocessing -Skript ausführen. Wir haben dies getan, indem wir das Multiprocessing -Modul als „M“ importiert haben. Benutze sie.Queue () ”-Technik, wir berufen die Multiprocessing -Methode„ Queue () “. Hier erstellen wir eine Variable namens "Warteschlange" und platzieren die multiprozessierende "Queue ()" -Methode darin. Wie wir wissen, dass die Warteschlange Elemente in einer Bestellung mit dem ersten In-In-Erst, dem zuerst hinzugefügten Element speichert, wird zuerst entfernt. Nachdem wir die Multiprocessing -Warteschlange gestartet haben, nennen wir die Methode „Print ()“ und geben die Anweisung „Es gibt eine Multiprocessing -Warteschlange“ als Argument, um sie auf dem Bildschirm anzuzeigen. Da wir dann die konstruierte Warteschlange in dieser Variablen speichern, drucken wir die Warteschlange, indem wir die Variable "Warteschlange" in der Klammung der "print ()" -Methode übergeben.

Das folgende Bild zeigt, dass die Python Multiprocessing -Warteschlange jetzt konstruiert ist. Die Druckanweisung wird zuerst angezeigt. Danach ist in der angegebenen Speicheradresse die Multiprozesationskalte aufgebaut. Es kann 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 Multiprozesationswarteschlange in Python

In diesem Fall bestimmen wir die Größe der Multiprocessing -Warteschlange. Um die Größe der Multiprozesationswarteschlange 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 mit dem Importieren des Python -Multiprocessing -Moduls als „M“, bevor wir den Code ausführen. Dann verwenden Sie die „M.Queue () ’Befehl, wir rufen die Multiprocessing -Funktion„ Queue () “auf und setzen das Ergebnis in die Variable" Warteschlangen "ein. Mit der Methode "put ()" fügen wir die Elemente in der folgenden Zeile zur Warteschlange hinzu. Diese Methode wird verwendet, um die Daten zu einer Warteschlange hinzuzufügen. Daher nennen wir "Warteschlange" mit der Methode "put ()" und liefern die Ganzzahlzahlen als Element in seiner Klammung. Die Zahlen, die wir hinzufügen, sind "1", "2", "3", "4", "5", "6" und "7" mit den Funktionen "put ()".

Darüber hinaus nennen wir die Größe der Multiprocessing -Warteschlange mit der Multiprocessing -Warteschlange "QSIZE ()", um die Größe der Multiprocessing -Warteschlange zu erhalten. In der neu gebildeten Variablen „Ergebnis“ speichern wir dann das Ergebnis der Methode „QSIZE ()“. Danach nennen wir die Methode "print ()" und bestehen die Anweisung "Die Größe der Multiprocessing -Warteschlange" ist als Parameter. Als nächstes nennen wir die Variable "Ergebnis" in der Funktion "print ()", da die Größe in dieser Variablen gespeichert wird.

Das Ausgangsbild hat die angezeigte Größe. Wenn wir die Funktion „put ()“ verwenden, um der Multiprocessing -Warteschlange und der Funktion „QSIZE ()“ sieben Elemente hinzuzufügen, um die Größe zu bestimmen, wird die Größe der Multiprocessing -Warteschlange „7“ angezeigt. Die Eingangsanweisung „Die Größe der Multiprozessing -Warteschlange“ wird vor der Größe angezeigt.

Beispiel 3: Verwenden der Methode „Put ()“ und „get ()“ in der Python -Multiprocessing -Warteschlange

Die Warteschlangenmethoden "Put () und" get () "aus der Python -Multiprozessing -Warteschlange werden in diesem Beispiel verwendet. Wir entwickeln in diesem Beispiel zwei benutzerdefinierte Funktionen. In diesem Beispiel definieren wir eine Funktion, um einen Prozess zu erstellen, der zufällige Ganzzahlen erzeugt. Wir verwenden auch die Methode "put ()", um sie einer Warteschlange hinzuzufügen. Mit der Methode „Put ()“ wird die Elemente in die Warteschlange gestellt. Um dann die Zahlen aus der Warteschlange abzurufen und ihre Werte zurückzugeben, schreiben wir eine andere 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.

Lassen Sie uns jetzt den Code implementieren. Zuerst importieren wir die vier Bibliotheken, aus denen dieses Skript besteht. Wir importieren zuerst "Schlaf" aus dem Zeitmodul, um die Ausführung für einige Zeit in Sekunden zu verzögern, gefolgt von „Zufälliger“ aus dem Zufallsmodul, das zur Erzeugung von Zufallszahlen verwendet wird, und dann „Prozess“ aus Multiprozessierung, da dieser Code einen Prozess erstellt und schließlich die "Warteschlange" aus der Multiprozessierung. Durch die erste Erstellung einer Klasseninstanz kann die Warteschlange verwendet werden. Standardmäßig legt dies eine unendliche Warteschlange oder eine Warteschlange ohne maximale Größe fest. Durch die Festlegung der Option MAX -Größe auf eine Zahl, die größer als Null ist, ist es möglich, eine Kreation mit einer Größenbeschränkung vorzunehmen.

Wir definieren eine Funktion. Da diese Funktion dann benutzerdefiniert ist, geben wir ihm den Namen „Funktion1“ und übergeben den Begriff „Warteschlange“ als Argument. Anschließend rufen wir die Funktion „print ()“ auf und übergeben sie den "Builder: Running", "Flush" und das Objekt "wahre" Anweisungen . Die Druckfunktion von Python verfügt über eine eindeutige Option namens Flush, mit der der Benutzer auswählen kann. Der nächste Schritt besteht darin, die Aufgabe zu generieren. Dazu verwenden wir "für" und 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, die „Wert“ ist.Dies zeigt an, dass die Funktion nun ihre fünf Iterationen beendet, wobei jede Iteration eine zufällige Ganzzahl von 0 bis 5 erzeugt.

Im folgenden Schritt nennen wir dann die Funktion „Sleep ()“ und bestehen das Argument „Wert“, um den Teil für eine bestimmte Anzahl von Sekunden zu verzögern. Dann nennen wir die "Warteschlange" mit der Methode "put ()", um den Wert der Warteschlange im Wesentlichen hinzuzufügen. Der Benutzer wird dann darüber informiert, dass es keine weiteren Arbeiten gibt, indem Sie die „Warteschlange aufrufen.Put () ”Methode noch einmal und übergeben Sie den Wert„ None “. Dann führen wir die "print ()" -Methode aus, bestehen die Anweisung "Builder: Ready" zusammen mit "Flush" und setzen sie auf "wahr".

Wir definieren nun eine zweite Funktion, "Funktion2", und weisen das Schlüsselwort „Warteschlange“ als Argument zu IT zu. Dann nennen wir die Funktion "print ()", während wir den Bericht übergeben "Benutzer: Running" und "Flush", die auf "True" eingestellt sind. Wir beginnen den Betrieb von „function2“ mithilfe der trugen Bedingung, um die Daten aus der Warteschlange zu nehmen und sie in die neu erstellte "Element" -Variable zu setzen. Dann verwenden wir den Zustand "if", "Element ist keine", um die Schleife zu unterbrechen, wenn die Bedingung wahr ist. Wenn kein Artikel 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 vom Wert erhaltene Element null ist. Im folgenden Schritt nennen wir dann die Funktion „print ()“ und geben den Bericht „Benutzer: Ready“ und „Flush = True“ an.

Anschließend geben wir den Hauptprozess mit dem "if-name = main_" ein. Wir erstellen eine Warteschlangen. Als nächstes erstellen wir einen Prozess, indem wir die Benutzerfunktion „Funktion2“ aufrufen. Dafür nennen wir die "Prozess" -Klasse. Innerhalb davon übergeben wir die "target = function2", um die Funktion im Prozess aufzurufen, das Argument "Warteschlange" zu übergeben und in der Variablen "user_process" zu speichern. Der Vorgang beginnt dann mit der Aufrufe der Methode "start ()" mit der Variablen "user_ process". Anschließend wiederholen wir dieselbe Prozedur, um die "Funktion1" im Vorgang aufzurufen und ihn in die Variable "Builder -Prozess" aufzurufen. Dann nennen wir die Prozesse mit der Methode „Join ()“, um auf die Ausführung zu warten.

Nachdem es jetzt vorgestellt wird, können Sie die Aussagen beider Funktionen in der Ausgabe sehen. Es wird die Elemente angezeigt, die wir mit den "Put ()" und "get ()" mit den "get ()" -Methoden hinzugefügt haben.

Abschluss

Wir haben in diesem Artikel die Python Multiprocessing -Warteschlange erfahren. Wir haben die angegebenen Illustrationen verwendet. Zuerst haben wir beschrieben. Dann haben wir die Methode „QSIZE ()“ verwendet, um die Warteschlangen der Warteschlange zu bestimmen . Wir haben auch die Methoden der Warteschlangenput () und get () verwendet. Die Schlafklasse des Zeitmoduls und die zufällige Klasse des Zufallsmoduls wurden im letzten Beispiel diskutiert.