Python Multiprocessing Pool

Die Bereitstellung von zwei oder sogar zentraleren Verarbeitungseinheiten im gesamten Prozessorsystem wird als Multiprozessierung bezeichnet. Die Funktionalität des Systems könnte durch Multiprozessierung erheblich verbessert werden. Python verwendet wegen GIL nur eine zentrale Verarbeitungseinheit. Im Gegensatz zu C -Sprache oder Java -Sprache, die sofort eine Multiprozessierung einsetzen. Es ist ein Stecker, mit dem nur ein Prozess gleichzeitig ausgeführt werden kann. Das Multiprocessing -Paket in Python kann daher dieses Problem beheben. Es gibt zwei Modi in diesem Gerät, die Prozess und den Pool umfassen. Diese können uns helfen, einen bestimmten Code -Stück gleichzeitig auszuführen.

Syntax der Pool () -Funktion:

Wir würden die Verfahren in der Prozessklasse ausdrücklich konstruieren. Obwohl die Poolklasse nützlicher zu sein scheint, weil wir dynamisch damit umgehen können. Verwenden Sie die Syntax, um ein Poolobjekt zu konstruieren, die Syntax:

Jeder Parameter ist optional. Der 'Initargs' ist der dritte Parameter, der an die Methode übergeben wird. Das 'maxtasksperchild' bezeichnet die Gesamtzahl der Operationen, die jedes Kinderprozess verabreicht wurde. Der Prozess würde nach Abschluss der Operationen mit einem neuen Arbeiterverfahren aktualisiert.

Lassen Sie uns den weiteren Multiprocessing -Pool besprechen:

Beispiel Nr. 1:
Schauen wir uns die Abbildung unten an, die das Quadrat der Ganzzahl berechnet und den Code für eine Sekunde schläft.

Importzeit
vom Multiprocessing -Importpool
Def Square (a):
print (f "Hier beginnt der Prozess: a")
quadratisch = a * a
print (f "quadratisch a: square")
Zeit.Schlaf (1)
print (f "ehere der Prozess endet: a")
Wenn __name__ == "__main__":
start_t = Zeit.Zeit()
Pool = Pool ()
Schwimmbad.Karte (Quadrat, Bereich (0, 9))
Schwimmbad.schließen()
end_t = Zeit.Zeit()
print (f "Die Gesamtzeit ist end_t-start_t Sekunden"))

Zu Beginn des Code müssen wir das Zeitmodul und das Poolmodul importieren. Die Poolbibliothek wird von der Multiprozessierung integriert. Wir definieren den Funktionsquadrat (). Als nächstes verwenden wir die Print () -Methode, um die Nachricht zu zeigen: "Hier beginnt der Prozess". Hier erhalten wir das Quadrat der Zahl, indem wir die Nummer miteinander multiplizieren. Noch einmal nennen wir die Print () -Funktion, um das Quadrat der definierten Nummer anzuzeigen. Wir definieren die Funktion sleep (), um den Zeitrahmen des Codes festzulegen.

Jetzt druckt die Druckanweisung die Zeile aus, die zeigt, dass der Prozess beendet wird. Beginnen wir mit dem Körper der Hauptfunktion. Wir rufen die Zeit () -Methode der Modulzeit auf. Wir erstellen einen Poolklassenartikel. Die Methode, die wir replizieren möchten und eine iterable.

Darüber hinaus akzeptiert es einen zusätzlichen "Chunkize" -Parameter, der die iterablen in gleich große Segmente unterteilt und diesen als eindeutiger Betrieb empfängt. Der Parameter zur MAP () -Methode wird als Bereich angewendet. Um neue Operationen zu verweigern, nutzen Sie den Pool.Close () Methode.

Beispiel Nr. 2:
In diesem Fall werden wir den Datenrahmen des Codes für 2 Sekunden lang mithilfe der Sleep () -Methode festlegen.

Importzeit
vom Multiprocessing -Importpool
Def Square (a):
print (f "Der Prozess beginnt jetzt a")
quadratisch = a * a
Zeit.Schlaf (2)
print (f "Der Prozess endet jetzt a")
Return Square
Wenn __name__ == "__main__":
Pool = Pool ()
x = Pool.Karte (Quadrat, Bereich (0, 7))
Druck (x)

Das Zeitpaket und das Poolpaket müssen zu Beginn des Programms importiert werden. Die Multiprozessierung wird in die Poolbibliothek integriert. Der Method Square () ist definiert. Die Meldung „Der Prozess beginnt jetzt“ wird dann mit der Funktion print () angezeigt. Durch Multiplizieren der Werte können wir das Quadrat der Zahl in diesem Szenario erhalten.

Um die Zeit des Codes festzulegen, rufen wir die Sleep () -Methode auf. Darüber hinaus zeigt der Druckbefehl eine Zeile an, die angibt, dass der Prozess beendet ist. Im Körper der Hauptfunktion werden wir die Methode pool () aufrufen. Die Funktion map () wurde in der nächsten Zeile verwendet. Diese Funktion enthält zwei Parameter. Das erste Argument zeigt das Quadrat der Zahl. Und der zweite Parameter verwendet die Methode range ().

Wir definieren die niedrigeren und höheren Grenzwerte innerhalb der Funktion von range (). Am Ende haben wir Print () angerufen, um das Ergebnis anzuzeigen.

Beispiel Nr. 3:
Unglaublich ähnlich dem Pool.MAP () -Funktion ist der Pool.IMAP (). Die Unterscheidung hier ist, dass das Ergebnis jedes Elements so sofort bereitgestellt wird, wie es verarbeitet wird, anstatt darauf zu warten, dass alle Elemente abgeschlossen sind. Zusätzlich wird das iterable in einen Satz von der Map () -Funktion umgewandelt. Die IMAP () -Technik tut daher nicht.

Importzeit
vom Multiprocessing -Importpool
Def Square (x1):
print (f "sthe process hat x1" gestartet)
Quadrat = x1 * x1
Zeit.Schlaf (9)
print (f "Der Prozess ist x1") beendet)
Return Square
Wenn __name__ == "__main__":
Pool = Pool ()
x2 = Pool.IMAP (Quadrat, Bereich (0, 4))
für j in x2:
print (f "Das Ergebnis ist hier j")

Erstens müssen wir den Zeit- und Pool -Framework einbeziehen. Wir nehmen die Poolbibliothek aus dem Multiprocessing -Paket. Wir nennen die Square () -Funktion. Diese Funktion enthält die erforderliche Zahl als Argument. Um die Meldung anzuzeigen, dass der Prozess gestartet wurde, haben wir die Funktion print () aufgerufen. Durch Multiplizieren der Werte in diesem Fall können wir das Quadrat der angegebenen Zahl erhalten. Um die Zeit des Codes zu bestimmen, berufen wir den Sleep () der Methode (). Die Anweisung, die angibt, dass der Prozess beendet ist, wurde von der Druckfunktion gedruckt. Das Quadrat der angegebenen Ganzzahl wird dann von der Funktion zurückgegeben.

Beginnen wir jetzt den Körper der Hauptfunktion. Die Funktion pool () wird verwendet. Die nächste Zeile verwendet die map () -Methode. Für diese Methode gibt es zwei Parameter. Das Quadrat der Ganzzahl wird als erster Parameter bereitgestellt. Die Funktion von Range () wird als zweites Argument verwendet. Innerhalb der Methode von Bereich () werden die unteren und oberen Einschränkungen angegeben. Bevor wir den Code beenden, werden wir die 'for' Loop verwenden. Wir initialisieren die Schleifenvariable. Diese Schleife iteriert, bis die angegebene Bedingung erfüllt ist. Danach wird die Print () -Methode angewendet, um das Ergebnis darzustellen.

Abschluss

In diesem Leitfaden haben wir über den Multiprocessing -Pool von Python gesprochen. Wenn zahlreiche Prozesse gleichzeitig funktionieren oder ein langwieriger Betrieb beschleunigt werden müssen, ist die Multiprozessierung von entscheidender Bedeutung. Wenn ein Prozess auf einem einzelnen Thread ausgeführt wird, sind seine Fähigkeiten eingeschränkt. Andernfalls würde dies seine Tentakel durch zahlreiche Fäden erstrecken. Python bietet eine einfache Schnittstelle zur Implementierung von Multiprozessierung, wenn der zeitaufwändige Betrieb gleichzeitig ausgeführt wird und das gesamte System viele Prozessorarchitekturen unterstützt. Wir haben drei Fälle ausgeführt, in denen wir den Zeitrahmen des Code festgelegt haben.