Share
Das Multiprocessing-Paket unterstützt Spawn-Prozesse mit einer API, die dem Threading-Modul ähnelt. Es bietet auch lokale und Remote-Parallelität. In diesem Lernprogramm werden Multiprocessing in Python und die Verwendung von Multiprocessing für die Kommunikation zwischen Prozessen und die Synchronisierung zwischen Prozessen sowie die Protokollierung erläutert.
Multiprocessing funktioniert durch Erstellen eines Verarbeiten Objekt und dann sein Aufruf Start() Methode wie unten gezeigt.
vom Multiprocessing-Import Prozess def-Begrüßung (): print 'Hallo Welt', wenn __name__ == '__main__': p = Prozess (Ziel = Begrüßung) p.start () p.join ()
Im obigen Beispielcode importieren wir zuerst die Process-Klasse und instanziieren dann das Process-Objekt mit der Begrüßungsfunktion, die wir ausführen möchten.
Wir sagen dann dem Prozess, dass Sie mit der Verwendung von beginnen sollen Start() Methode, und wir schließen den Prozess schließlich mit der Beitreten() Methode.
Darüber hinaus können Sie der Funktion auch Argumente übergeben, indem Sie das angeben args Keyword-Argument wie folgt:
Accentsconagua
vom Multiprocessing-Import Prozess def Begrüßung (Name): print 'Hallo' + "" + Name, wenn __name__ == '__main__': p = Prozess (Ziel = Begrüßung, args = ('world',)) p.start () p .Beitreten() Schauen wir uns ein detaillierteres Beispiel an, das alle oben diskutierten Konzepte abdeckt.
In diesem Beispiel erstellen wir einen Prozess, der das Quadrat der Zahlen berechnet und die Ergebnisse an die Konsole ausgibt.
von Multiprocessing-Import Prozess viereckig (x): für x in Zahlen: print ('% s quadriert ist% s'% (x, x ** 2)), wenn __name__ == '__main__': numbers = [43, 50, 5, 98, 34, 35] p = Prozess (Ziel = Quadrat, args = ('x',)) p.start () p.join print "Done" #result Done 43 ist quadratisch 1849 50 quadratisch ist 2500 5 quadratisch ist 25 98 Quadrat ist 9604 34 Quadrat ist 1156 35 Quadrat ist 1225 Sie können auch mehrere Prozesse gleichzeitig erstellen, wie im folgenden Beispiel gezeigt. Dabei erhält p1 die Ergebnisse der Zahlen im Quadrat, während der zweite Prozess p2 prüft, ob die angegebenen Zahlen gerade sind.
vom Multiprocessing-Import Prozess def Quadrat (x): für x in Zahlen: print ('% s squared ist% s'% (x, x ** 2)) def is_even (x): für x in Zahlen: wenn x% 2 == 0: print ('% s ist eine gerade Zahl'% (x)) wenn __name__ == '__main__': numbers = [43, 50, 5, 98, 34, 35] p1 = Prozess (Ziel = Quadrat, args = ('x',)) p2 = Prozess (target = is_even, args = ('x',)) p1.start () p2.start () p1.join () p2.join () print "Fertig" #Ergebnis 43 Quadrat ist 1849 50 Quadrat ist 2500 5 Quadrat ist 25 98 Quadrat ist 9604 34 Quadrat ist 1156 35 Quadrat ist 1225 50 ist eine gerade Zahl 98 ist eine gerade Zahl 34 ist eine gerade Zahl Fertig Multiprocessing unterstützt zwei Arten von Kommunikationskanälen zwischen Prozessen:
Warteschlange Objekte werden verwendet, um Daten zwischen Prozessen zu übergeben. Sie können alle pickle-fähigen Python-Objekte speichern und Sie können sie wie im folgenden Beispiel verwenden:
import multiprocessing def is_even (zahlen, q): für n in zahlen: wenn n% 2 == 0: q.put (n) wenn __name__ == "__main__": q = multiprocessing.Queue () p = multiprocessing.Process ( target = is_even, args = (Bereich (20), q)) p.start () p.join (), während q: print (q.get ())
Im obigen Beispiel erstellen wir zuerst eine Funktion, die prüft, ob eine Zahl gerade ist, und setzen das Ergebnis dann am Ende der Warteschlange. Wir instanziieren dann ein Warteschlangenobjekt und ein Prozessobjekt und beginnen den Prozess.
Schließlich überprüfen wir, ob die Warteschlange leer ist. Wenn dies nicht der Fall ist, werden die Werte von der Vorderseite der Warteschlange abgerufen und an die Konsole ausgegeben.
Wir haben gezeigt, wie Daten über eine Warteschlange zwischen zwei Prozessen gemeinsam genutzt werden können. Das Ergebnis ist wie folgt.
# Ergebnis 0 2 4 6 8 10 12 14 16 18
Es ist auch wichtig zu beachten, dass Python ein Warteschlangenmodul hat, das sich im Prozessmodul befindet und zum Freigeben von Daten zwischen Threads verwendet wird, im Gegensatz zu der Multiprocessing-Warteschlange, die sich im gemeinsam genutzten Speicher befindet und zum Datenaustausch zwischen Prozessen verwendet wird.
Pipes im Multiprocessing werden hauptsächlich für die Kommunikation zwischen Prozessen verwendet. Die Nutzung ist so einfach wie:
vom Multiprocessing-Importprozess, Pipe def f (conn): conn.send (['hello world']) conn.close () wenn __name__ == '__main__': parent_conn, child_conn = Pipe () p = Prozess (Ziel = f , args = (child_conn,)) p.start () print parent_conn.recv () p.join ()
Rohr() gibt zwei Verbindungsobjekte zurück, die die beiden Enden der Pipe darstellen. Jedes Verbindungsobjekt hat senden() und recv () Methoden. Hier erstellen wir einen Prozess, der den String druckt Hallo Welt und gibt dann die Daten weiter.
# Ergebnis ['Hallo Welt']
Schlösser Stellen Sie sicher, dass jeweils nur ein Prozess ausgeführt wird, sodass andere Prozesse keinen ähnlichen Code ausführen können. Dadurch kann der Vorgang abgeschlossen werden und erst dann kann die Sperre aufgehoben werden.
Das folgende Beispiel zeigt eine recht einfache Verwendung der Lock-Methode.
aus dem Multiprocessing-Importprozess, Festlegen der Begrüßung (l, i): l.acquire () print 'Hallo', ich l.release (), wenn __name__ == '__main__': lock = Lock () names = ['Alex', 'sam', 'Bernard', 'Patrick', 'Jude', 'Williams'] für Namen in Namen: Prozess (Ziel = Begrüßung, args = (Sperre, Name)). start () #result hallo Alex hallo sam hallo Bernard Hallo Patrick Hallo Jude Hallo Williams
In diesem Code importieren wir zuerst die Lock-Methode, erfassen sie, führen die Druckfunktion aus und geben sie dann frei.
Das Multiprocessing-Modul bietet auch Unterstützung für die Protokollierung, obwohl das Protokollierungspaket keine Sperren verwendet, sodass Nachrichten zwischen Prozessen während der Ausführung möglicherweise durcheinander geraten.
Die Verwendung der Protokollierung ist so einfach wie:
Multiprocessing importieren, logging logger = multiprocessing.log_to_stderr () logger.setLevel (logging.INFO) logger.warning ('Fehler ist aufgetreten')Hier importieren wir zuerst die Logging- und Multiprocessing-Module und definieren dann die multiprocessing.log_to_stderr () Methode, die einen Aufruf an ausführt get_logger () sowie einen Handler hinzufügen, der die Ausgabe an sendet sys.stderr. Zum Schluss legen wir die Logger-Ebene und die Nachricht fest, die wir vermitteln möchten.
In diesem Lernprogramm wurde beschrieben, was für den Einstieg in die Multiprozedur in Python erforderlich ist. Multiprocessing bewältigt das Problem der GIL (Global Interpreter Lock), da hier Subprozesse anstelle von Threads verwendet werden.
In der Python-Dokumentation gibt es noch viel mehr, was in diesem Lernprogramm nicht behandelt wird. Besuchen Sie also die Python-Multiprocessing-Dokumente und nutzen Sie die volle Leistungsfähigkeit dieses Moduls.
