Python Multiprocessing -Beispiel

Python ist eine Programmiersprache, die für die Entwicklung von Websites und Anwendungen von Vorteil ist. Auch in die Datenvisualisierung und -analyse beteiligt. Es ist vergleichsweise eine einfache Sprache und wird häufig auch von Nichtprogrammern verwendet. Dieser Artikel bezieht sich auf die Verwendung von Multiprozessing in Python.

Multiprozessierung

Multiprocessing befasst sich mit dem Potenzial eines Systems, das mehr als einen Prozessor gleichzeitig unterstützt. Alle Anwendungen bei der Multiprozessierung werden in kleine Muster zerlegt, und jedes dieser Muster ist selbstabhängig von der Arbeiten. In dieser Art von Prozess werden zwei oder mehr Prozesse verwendet. Lassen Sie uns einfach in Betracht ziehen, dass ein Computer unter Verwendung eines einzelnen Prozessors ausgeführt wird. Wenn wir mehrere Prozessoren gleichzeitig zuweisen, wird jeder Aufgabe nach kurz. Mit anderen Worten, wenn weitere Aufgaben erledigt werden müssen, wird es schwieriger sein, sie auf dem Laufenden zu halten, um die Fertigstellung zu erhalten. Während es auch eine große Herausforderung ist, jede gleiche Aufgabe zuzuweisen. In diesem Zustand müssen wir das Konzept der Multiprozessierung entstehen. Ein Multiprozessingsystem kann es ermöglichen.

• Multiprozessor: Ein Computer, der mehr als einen zentralen Prozessor verwendet.
• Multi-Core-Prozessor: Eine einzelne Komponente, die zwei oder mehr Verarbeitungseinheiten verwendet.

Multiprozessierung in Python

Mit dem Multiprocessing -Konzept kann die zentrale Verarbeitungseinheit einfach mehrere Aufgaben zu einem einzigen Zeitpunkt ausführen. Python verwendet das Multiprocessing -Modul, um parallele Codes einzuführen. Um die Multiprozessierung zu implementieren, müssen Sie zunächst die Anzahl der Kerne in Ihrem System kennen. Wir haben hier einen einzelnen Code verwendet, um über den CPUs zu wissen, der jeweils funktioniert.

Für Python können Sie jedes andere Tool verwenden, um die Codes zu erreichen. Wir haben das Spyder -Tool für diesen Zweck verwendet, der sicherlich die Python -Sprachcodes ausführt.

Multiprozessierung importieren

print ("Anzahl der CPU:", Multiprocessing.cpu_count ())

Zunächst müssen wir das Paket „PG“ -Multiprozessing importieren, das das Arbeiten ermöglicht. Für jeden PC kann der Ausgang variieren. Für mich ist die Anzahl der Kerne 4.

Beispiel 1:

Mit einem Multiprozessungsmodul berechnen wir die Cube- und Quadratfunktionen.

Lassen Sie uns den oben genannten Code verstehen. Wir haben einen Prozess erstellt und dann ein Objekt erstellt, um die Klasse zu verarbeiten.

P1 = multiprocessing.Prozess (print (print_cube (5,)))
P2 = Multiprozessing.Prozess (print (print_square (2,)))

P1 und P2 sind die Objekte der Prozesse. Diese Prozesse enthalten den Funktionsaufruf mit einer Druckfunktion, mit der die Funktion direkt mit Argumenten als Parameter aufgerufen wird. Print_cube und print_square.

Wir verwenden Startmethoden, um den Prozess zu starten.

P1.Start()
P2.Start()

Eine der verwendeten Funktionen wird beschrieben als.

Def print_square (num):
print ("quadratisch: ".Format (num * num))

Die Quadratfunktion berechnet das Quadrat durch Multiplizieren der angegebenen Nummer, die im Funktionsaufruf verwendet wird. Die Funktion nimmt die Zahl in der Variablen „Num“ ein.

Wenn wir den Code ausführen, zeigt die Ausgabe die resultierenden Werte beider Funktionen an.

Beispiel 2:

Mit Datenstrukturen müssen Sie mit der Verwendung von Stapeln und Warteschlangen in der Programmiersprache vertraut sein. Aus dem Multiprocessing -Modul importieren wir hier eine Warteschlangenklasse, die die FIFO -Datenstruktur (zuerst in der ersten Out) ist. Es wird zwei Prozesse geben, die alternativ funktionieren. Wir verwenden hier zwei Funktionen. Put () Funktion wird hier verwendet, um Daten in die Warteschlange einzufügen. Während wir Get () verwenden, um die Elemente aus der Warteschlange abzurufen. Unten ist der Code, der die Arbeit der Multiprozessierung in der Warteschlange veranschaulicht. Der erste Schritt besteht darin, Warteschlangen einzuführen.

Aus Multiprocessing -Importwarteschlange

Führen Sie nach dem Import des Moduls die Namen von Autos in die Array -Variable ein. Wir werden eine für die Schleife verwenden. Eine "CNT" -Variable wird verwendet, um die Anzahl der verwendeten Autos zu zählen. Initialisieren Sie das Warteschlangenobjekt über die Anweisung.

Queue = Queue ()

Dann wird eine Schleife verwendet, um Werte hinzuzufügen; Dadurch wird ein Schlüsselwort "Warteschlangen" verwendet, um die Funktion Put () zu verwenden, um als der zugefügte Name des Autos zu argumentieren. Die Funktion „CNT“ wird nach jedem Einfügen erhöht.

Für Auto in Autos:

Warteschlange.Setzen Sie (Auto)
Cnt += 1

In ähnlicher Weise wird für put () eine während der gesamten Warteschlange verwendet, bis die gesamte Warteschlange nicht leer ist.

Während keine Warteschlange.leer():

Print ('Artikel Nr.', CNT, ", Warteschlange.erhalten())
Cnt+= 1

Die Ausgabe zeigt beide Funktionen, die unabhängig funktionieren. Sobald eine Funktion ihre Arbeit erfüllt, ist der andere Prozess verwendet.

Beispiel 3:

Dieses Beispiel enthält zwei Prozesse. In jedem Prozess wird „PID“ durch die Get () -Funktion erhalten. Wir haben zwei Module verwendet. Einer ist multiprozesend und das andere ist Betriebssystem -Betriebssystem.

Jedem Prozess wird eine andere ID zugewiesen.

Def process ():

Print ("id des Prozesslaufs Worker1: ".Format (Betriebssystem.getPid ()))

Die Nachricht wird mit dem Funktionsaufruf verkettet, um die Prozess -ID zu empfangen. Im Hauptprogramm wird die Hauptprozess -ID mit demselben Ansatz über den Get () abgerufen. Dann werden Prozesse durch Multiprozessierung erstellt. Auf jeden Prozess wird über seine jeweiligen Objekte zugegriffen. ich.e., Für den Prozess 1 ist das Objekt P1.

P1 = multiprocessing.Prozess (Ziel = prozess1)

Ziel ist die Funktion, die vom Prozess ausgeführt werden soll. Wenn die Prozesse erstellt werden, müssen sie anfangen. Der Status jedes Prozesses wird angezeigt; Dafür müssen wir den Abschluss des Prozesses überwachen. Dies braucht einige Zeit, um zu warten. Wir werden eine Funktion verwenden, die bis zur vollständigen Ausführung des Prozesses warten wird.

P1.verbinden()

Wenn diese Verbindungsfunktion das Signal erhält, wird die Anweisung ausgedruckt, dass die Ausführung abgeschlossen ist. Eine boolesche Flagge bestimmt entweder, dass der Prozess lebt oder nicht. Wenn ja, dann ist es wahr, sonst ist es falsch.

Print („Prozess P1 ist lebendig: “.Format (P1.ist am Leben()))

Führen Sie nun das Programm aus und nehmen Sie die Ausgabe an. Sie können zuerst sehen, dass die Haupt -ID angezeigt wird und dann die Prozess -ID jedes Prozesses. Nach Abschluss der Ausführung wird der Status für beide Prozesse angezeigt, das ist „falsch“, das ist „falsch“.

Beispiel 4:

In diesem Beispiel sehen Sie die Arbeit des Multiprozessing- und Importzeit, Pools, CPU_COUNT. Der Pool wird verwendet, um Prozesse mit mehreren Eingaben auszuführen und diese Eingabedaten auf die Prozesse zu verteilen. Eine quadratische Funktion berechnet das Quadrat des Eingangswerts. Durch die Verwendung des Zeitmoduls aus dem Paket werden wir die Schlaffunktion verwenden.

Zeit.Schlaf (3)

Diese Funktion hat eine Zeitausdehnung von 3 Sekunden. Dies bedeutet, dass der Wert dieser Funktion nach dieser bestimmten Zeit angezeigt wird. Im Hauptprogramm starten wir den Timer, und dann werden die Dummy -Werte jeder 4 Kerne zugewiesen.

Mit Pool () als Pool:

Res = Pool.Karte (Quadrat, Werte)
Druck (res)

Die Poolfunktion gibt Werte an und das gleichzeitige Aufrufen der Funktion. Dann müssen wir den Timer stoppen. Diese Timer -Funktion zählt die für diese Funktion verwendeten Sekunden, die als verstrichene Zeit bezeichnet werden. Es wird erhalten, indem der Startwert der Zeit vom Endwert subtrahiert.

Führen Sie nun das Programm aus. Die erste Zeile wird angezeigt, und dann dauert es 3 Sekunden. Danach wird ein weiteres Ergebnis gezeigt.

Abschluss

"Python Multiprocessing -Beispiel" ist eine kurze Einführung in das Multiprozessing -Phänomen. Jedes hier erläuterte Beispiel importiert verschiedene Pakete aus dem Multiprocessing -Modul. Dieser Umgang mit Prozessen parallel zueinander wird durch die Anzahl der CPUs erreicht. Mehr die Anzahl der CPUs größer ist die Wahrscheinlichkeit einer guten Multiprozessierung.