Ein Leitfaden zur Python -Multiprocessing und zur parallele Programmierung

Berechnungen beschleunigen ist ein Ziel, das jeder erreichen möchte. Was ist, wenn Sie ein Skript haben, das zehnmal schneller ausgeführt werden könnte als die aktuelle Laufzeit? In diesem Artikel werden wir uns Python Multiprocessing und eine Bibliothek namens Multiprocessing ansehen. Wir werden darüber sprechen, was Multiprocessing ist, seine Vorteile und wie Sie die Laufzeit Ihrer Python -Programme verbessern können, indem Sie parallele Programme verwenden.

Okay, also lass uns gehen!

Key Takeaways

• Parallele Computing ist eine Methode zur Beschleunigung von Berechnungen, indem mehrere Kerne einer CPU gleichzeitig verwendet werden. Dies kann in Python durch Multiprocessing erreicht werden, ein Modul, das die Erstellung mehrerer Prozesse ermöglicht, die jeweils auf einem separaten Kern ausgeführt werden.
Das Multiprozesationsmodul von Python bietet Vorteile wie eine bessere Nutzung der CPU für hochintensive Aufgaben, mehr Kontrolle über Kinderprozesse im Vergleich zu Threads und eine einfache Implementierung für Aufgaben, die für die parallele Programmierung geeignet sind.
Python -Multiprozessierung ist nicht immer effizienter als serielles Computing. Bei niedrigen CPU-intensiven Aufgaben kann die serielle Berechnung aufgrund des Overheads schneller sein, das durch Aufteilen von Berechnungen zwischen den Prozessen eingeführt wird.
Das Multiprocessing -Modul in Python erstellt einen neuen Prozess für jede Aufgabe, die gleichzeitig ausgeführt werden muss. Jeder Prozess hat seinen eigenen Python -Interpreter und einen Speicherraum, der es ihm ermöglicht, unabhängig von anderen Prozessen auszuführen.
Während die Multiprozesation in Python die Geschwindigkeit und Effizienz eines Programms erheblich verbessern kann, erhöht es auch die Komplexität des Codes. Nicht alle Aufgaben sind für die Parallelisierung geeignet, und in einigen Fällen kann der Overhead der Erstellung und Verwaltung mehrerer Prozesse die potenziellen Leistungsgewinne überwiegen.

Eine Einführung in die Parallelität

Bevor wir in Python Code eintauchen, müssen wir über Parallel Computing sprechen, was ein wichtiges Konzept in der Informatik ist.

Wenn Sie ein Python -Skript ausführen, wird Ihr Code normalerweise irgendwann zum Prozess und der Prozess wird auf einem einzigen Kern Ihrer CPU ausgeführt. Aber moderne Computer haben mehr als einen Kern. Was ist also, wenn Sie mehr Kerne für Ihre Berechnungen verwenden könnten? Es stellt sich heraus, dass Ihre Berechnungen schneller sein werden.

Nehmen wir dies vorerst als allgemeines Prinzip, aber später in diesem Artikel werden wir sehen, dass dies nicht allgemein wahr ist.

Ohne auf zu viele Details einzugehen, ist die Idee hinter der Parallelität, Ihren Code so zu schreiben, dass er mehrere Kerne der CPU verwenden kann.

Um die Dinge einfacher zu machen, schauen wir uns ein Beispiel an.

paralleles und serielles Computing

Stellen Sie sich vor, Sie haben ein großes Problem zu lösen, und Sie sind allein. Sie müssen die Quadratwurzel von acht verschiedenen Zahlen berechnen. Was machst du? Nun, Sie haben nicht viele Möglichkeiten. Sie beginnen mit der ersten Zahl und berechnen das Ergebnis. Dann fahren Sie mit den anderen fort.

Was ist, wenn Sie drei Freunde haben, die gut in Mathe sind, die Ihnen helfen möchten? Jeder von ihnen berechnet die Quadratwurzel von zwei Zahlen, und Ihr Job wird einfacher, da die Arbeitsbelastung gleichermaßen zwischen Ihren Freunden verteilt ist. Dies bedeutet, dass Ihr Problem schneller gelöst wird.

Okay, also alles klar? In diesen Beispielen repräsentiert jeder Freund einen Kern der CPU. Im ersten Beispiel wird die gesamte Aufgabe nacheinander von Ihnen gelöst. Dies wird als Seriencomputer bezeichnet. Im zweiten Beispiel verwenden Sie, da Sie insgesamt mit vier Kernen arbeiten, Parallel Computing. Parallele Computing beinhaltet die Verwendung paralleler Prozesse oder Prozesse, die in mehreren Kernen in einem Prozessor unterteilt sind.

Modelle für die parallele Programmierung

Wir haben festgestellt, was parallele Programmierung ist, aber wie verwenden wir sie? Nun, wir sagten zuvor, dass das parallele Computing die Ausführung mehrerer Aufgaben zwischen mehreren Kernen des Prozessors umfasst, was bedeutet, dass diese Aufgaben gleichzeitig ausgeführt werden. Es gibt einige Fragen, die Sie berücksichtigen sollten, bevor Sie sich der Parallelisierung nähern. Gibt es beispielsweise andere Optimierungen, die unsere Berechnungen beschleunigen können?

Nehmen wir vorerst an, dass die Parallelisierung die beste Lösung für Sie ist. Es gibt hauptsächlich drei Modelle im parallelen Computer:

• perfekt parallel. Die Aufgaben können unabhängig ausgeführt werden und müssen nicht miteinander kommunizieren.
• gemeinsames Gedächtnisparallelität. Prozesse (oder Fäden) müssen kommunizieren, damit sie einen globalen Adressraum teilen.
• Nachricht zum Passieren. Prozesse müssen bei Bedarf Nachrichten freigeben.

In diesem Artikel werden wir das erste Modell veranschaulichen, das auch das einfachste ist.

Python-Multiprozessing: prozessbasierte Parallelität in Python

Eine Möglichkeit, die Parallelität in Python zu erreichen, besteht darin, das Multiprozessungsmodul zu verwenden. Mit dem Multiprocessing -Modul können Sie mehrere Prozesse erstellen, von denen jeder mit einem eigenen Python -Interpreter. Aus diesem Grund führt die Python-Multiprozessierung prozessbasierte Parallelität durch.

Sie haben vielleicht von anderen Bibliotheken gehört, wie Threading, die auch mit Python integriert sind, aber es gibt entscheidende Unterschiede zwischen ihnen. Das Multiprocessing -Modul erstellt neue Prozesse, während Threading neue Threads erstellt.

Im nächsten Abschnitt werden wir uns mit den Vorteilen der Verwendung von Multiprocessing befassen.

Vorteile der Verwendung von Multiprocessing

Hier sind einige Vorteile der Multiprozessierung:

• Bessere Verwendung der CPU im Umgang mit hohen CPU-intensiven Aufgaben
Mehr Kontrolle über ein Kind im Vergleich zu Threads
einfach zu codieren

Der erste Vorteil hängt mit der Leistung zusammen. Da Multiprocessing neue Prozesse erzeugt, können Sie die Rechenleistung Ihrer CPU viel besser nutzen, indem Sie Ihre Aufgaben unter den anderen Kernen teilen. Meisten

Der zweite Vorteil befasst sich mit einer Alternative zur Multiprozessierung, die Multithreading ist. Themen sind jedoch keine Prozesse, und dies hat seine Konsequenzen. Wenn Sie einen Thread erstellen, ist es gefährlich, ihn zu töten oder sogar zu unterbrechen, wie Sie es mit einem normalen Prozess ausführen würden. Da der Vergleich zwischen Multiprozessing und Multithreading nicht im Rahmen dieses Artikels liegt, ermutige ich Sie, weitere Lesen darüber zu lesen.

Der dritte Vorteil der Multiprozessierung besteht darin, dass es recht einfach ist, da die Aufgabe, die Sie zu erledigen möchten, für eine parallele Programmierung geeignet ist.

Erste Schritte mit Python Multiprocessing

Wir sind endlich bereit, einen Python -Code zu schreiben!

wir beginnen mit einem sehr grundlegenden Beispiel und verwenden es, um die Kernaspekte der Python -Multiprozessierung zu veranschaulichen. In diesem Beispiel haben wir zwei Prozesse:

• Der übergeordnete Prozess. Es gibt nur einen übergeordneten Prozess, der mehrere Kinder haben kann.
• Der Kinderprozess. Dies wird vom Elternteil hervorgebracht. Jedes Kind kann auch neue Kinder haben.

Wir werden den untergeordneten Prozess verwenden, um eine bestimmte Funktion auszuführen. Auf diese Weise kann der Elternteil seine Ausführung fortsetzen.

Ein einfaches Beispiel für Python -Multiprocessing

Hier ist der Code, den wir für dieses Beispiel verwenden werden:

<span>from multiprocessing import Process
</span>
<span>def bubble_sort(array):
</span>    check <span>= True
</span>    <span>while check == True:
</span>      check <span>= False
</span>      <span>for i in range(0, len(array)-1):
</span>        <span>if array[i] > array[i+1]:
</span>          check <span>= True
</span>          temp <span>= array[i]
</span>          array<span>[i] = array[i+1]
</span>          array<span>[i+1] = temp
</span>    <span>print("Array sorted: ", array)
</span>
<span>if __name__ == '__main__':
</span>    p <span>= Process(target=bubble_sort, args=([1,9,4,5,2,6,8,4],))
</span>    p<span>.start()
</span>    p<span>.join()
</span>

In diesem Snippet haben wir eine Funktion namens Bubble_Sort (Array) definiert. Diese Funktion ist eine wirklich naive Implementierung des Blasensortierungsalgorithmus. Wenn Sie nicht wissen, was es ist, machen Sie sich keine Sorgen, denn es ist nicht so wichtig. Das entscheidende zu wissen, ist, dass es eine Funktion ist, die einige Arbeit leistet.

Die Prozessklasse

von Multiprocessing importieren wir den Klassenprozess. Diese Klasse stellt eine Aktivität dar, die in einem separaten Prozess ausgeführt wird. In der Tat können Sie sehen, dass wir einige Argumente bestanden haben:

target = bubble_sort, was bedeutet, dass unser neuer Prozess die Funktion bubble_sort
• ausführt
args = ([1,9,4,52,6,8,4],), das das Array als Argument an die Zielfunktion

, ist

Sobald wir eine Instanz für die Prozessklasse erstellt haben, müssen wir den Prozess nur starten. Dies geschieht durch das Schreiben von P.Start (). Zu diesem Zeitpunkt wird der Prozess gestartet.

Bevor wir beenden, müssen wir warten, bis der Kinderprozess seine Berechnungen beendet hat. Die join () -Methode wartet darauf, dass der Prozess endet.

In diesem Beispiel haben wir nur einen Kinderprozess erstellt. Wie Sie vielleicht vermuten, können wir mehr Kinderprozesse erstellen, indem wir mehr Instanzen in der Prozessklasse erstellen.

Die Poolklasse

Was ist, wenn wir mehrere Prozesse erstellen müssen, um mehr CPU-intensive Aufgaben zu erledigen? Müssen wir immer explizit auf die Kündigung beginnen und warten? Die Lösung hier ist die Verwendung der Poolklasse.

Mit der Poolklasse können Sie einen Pool von Arbeitsprozessen erstellen, und im folgenden Beispiel werden wir uns ansehen, wie wir ihn verwenden können. Dies ist unser neues Beispiel:

<span>from multiprocessing import Process
</span>
<span>def bubble_sort(array):
</span>    check <span>= True
</span>    <span>while check == True:
</span>      check <span>= False
</span>      <span>for i in range(0, len(array)-1):
</span>        <span>if array[i] > array[i+1]:
</span>          check <span>= True
</span>          temp <span>= array[i]
</span>          array<span>[i] = array[i+1]
</span>          array<span>[i+1] = temp
</span>    <span>print("Array sorted: ", array)
</span>
<span>if __name__ == '__main__':
</span>    p <span>= Process(target=bubble_sort, args=([1,9,4,5,2,6,8,4],))
</span>    p<span>.start()
</span>    p<span>.join()
</span>

In diesem Code -Snippet haben wir eine Würfelfunktion (x), die einfach eine Ganzzahl erfordert und seine quadratische Wurzel zurückgibt. Einfach, richtig?

Dann erstellen wir eine Instanz der Poolklasse, ohne ein Attribut anzugeben. Die Poolklasse erstellt standardmäßig einen Prozess pro CPU -Kern. Als nächstes führen wir die Kartenmethode mit ein paar Argumenten aus.

Die Kartenmethode wendet die Würfelfunktion auf jedes Element des iterablen an, das wir bereitstellen - was in diesem Fall eine Liste jeder Zahl von 10 bis N.

ist

Der große Vorteil davon ist, dass die Berechnungen auf der Liste parallel geschehen!

Nutze der Python -Multiprocessing

am besten verwendet

Erstellen mehrerer Prozesse und parallele Berechnungen ist nicht unbedingt effizienter als serielles Computing. Bei niedrigen CPU-intensiven Aufgaben ist die serielle Berechnung schneller als die parallele Berechnung. Aus diesem Grund ist es wichtig zu verstehen, wann Sie Multiprocessing verwenden sollten - was von den Aufgaben abhängt, die Sie ausführen.

Um Sie davon zu überzeugen, schauen wir uns ein einfaches Beispiel an:

<span>from multiprocessing import Pool
</span><span>import time
</span><span>import math
</span>
N <span>= 5000000
</span>
<span>def cube(x):
</span>    <span>return math.sqrt(x)
</span>
<span>if __name__ == "__main__":
</span>    <span>with Pool() as pool:
</span>      result <span>= pool.map(cube, range(10,N))
</span>    <span>print("Program finished!")
</span>

Dieses Snippet basiert auf dem vorherigen Beispiel. Wir lösen das gleiche Problem, nämlich die Quadratwurzel von N -Zahlen, jedoch auf zwei Arten. Der erste beinhaltet die Verwendung von Python -Multiprozessing, während der zweite nicht. Wir verwenden die Methode perf_counter () aus der Zeitbibliothek, um die Zeitleistung zu messen.

Auf meinem Laptop bekomme ich dieses Ergebnis:

<span>from multiprocessing import Pool
</span><span>import time
</span><span>import math
</span>
N <span>= 5000000
</span>
<span>def cube(x):
</span>    <span>return math.sqrt(x)
</span>
<span>if __name__ == "__main__":
</span>    <span># first way, using multiprocessing
</span>    start_time <span>= time.perf_counter()
</span>    <span>with Pool() as pool:
</span>      result <span>= pool.map(cube, range(10,N))
</span>    finish_time <span>= time.perf_counter()
</span>    <span>print("Program finished in {} seconds - using multiprocessing".format(finish_time-start_time))
</span>    <span>print("---")
</span>    <span># second way, serial computation
</span>    start_time <span>= time.perf_counter()
</span>    result <span>= []
</span>    <span>for x in range(10,N):
</span>      result<span>.append(cube(x))
</span>    finish_time <span>= time.perf_counter()
</span>    <span>print("Program finished in {} seconds".format(finish_time-start_time))
</span>

Wie Sie sehen, gibt es mehr als einen Sekundenspunkt. In diesem Fall ist die Multiprozessierung besser.

Lassen Sie uns etwas im Code ändern, wie den Wert von N. Lassen Sie uns auf n = 10000 senken und sehen, was passiert.

Das bekomme ich jetzt:

<span>> python code.py
</span>Program finished <span>in 1.6385094 seconds - using multiprocessing
</span>---
Program finished <span>in 2.7373942999999996 seconds
</span>

Was ist passiert? Es scheint, dass Multiprocessing jetzt eine schlechte Wahl ist. Warum?

Der Overhead, der durch Aufspalten der Berechnungen zwischen den Prozessen eingeführt wird, ist im Vergleich zu der gelösten Aufgabe zu stark. Sie können sehen, wie viel Unterschied es in Zeitaufführungen gibt.

Schlussfolgerung

In diesem Artikel haben wir über die Leistungsoptimierung des Python -Codes mithilfe von Python -Multiprocessing gesprochen.

Erstens haben wir kurz vorgestellt, was paralleles Computer ist und die Hauptmodelle dafür. Dann sprachen wir über Multiprocessing und seine Vorteile. Am Ende sahen wir, dass die Parallelisierung der Berechnungen nicht immer die beste Wahl ist, und das Multiprozessungsmodul sollte zur parallelisierenden CPU-gebundenen Aufgaben verwendet werden. Wie immer geht es darum, das spezifische Problem zu berücksichtigen, mit dem Sie konfrontiert sind, und die Vor- und Nachteile der verschiedenen Lösungen zu bewerten.

Ich hoffe, Sie haben festgestellt

FAQs über die Python -Multiprozessing und die parallele Programmierung

Was ist der Hauptvorteil bei der Verwendung von Multiprozessing in Python? Dies ist besonders vorteilhaft bei der Arbeit mit CPU-intensiven Aufgaben, da das Programm mehrere Kerne der CPU nutzen kann, wodurch die Geschwindigkeit und Effizienz des Programms erheblich verbessert wird. Im Gegensatz zum Gewinde leidet die Multiprozessierung nicht an der globalen Interpreter -Sperre (GIL) in Python, was bedeutet, dass jeder Prozess unabhängig laufen kann, ohne von anderen Prozessen betroffen zu sein. Dies macht Multiprocessing zu einem leistungsstarken Werkzeug für die parallele Programmierung in Python. gleichzeitig ausgeführt werden. Jeder Prozess hat einen eigenen Python -Interpreter und einen eigenen Speicherplatz, was bedeutet, dass er unabhängig von anderen Prozessen ausgeführt werden kann. Das Multiprocessing -Modul bietet eine Reihe von Klassen und Funktionen, mit denen diese Prozesse einfach erstellt und verwaltet werden können. Zum Beispiel wird die Prozessklasse verwendet, um einen neuen Prozess zu erstellen, während die Poolklasse zum Verwalten eines Pools von Arbeitsprozessen verwendet wird. > Der Hauptunterschied zwischen Multiprozessing und Multithreading in Python liegt in der Art und Weise, wie sie mit Aufgaben umgehen. Während Multiprocessing für jede Aufgabe einen neuen Prozess erstellt, erstellt Multithreading einen neuen Thread im selben Prozess. Dies bedeutet, dass Multithreading zwar mehrere CPU -Kerne durch die globale Interpreter -Sperre (GIL) in Python begrenzt wird, wodurch nur ein Thread gleichzeitig ausgeführt wird. Multithreading kann jedoch immer noch für I/O-gebundene Aufgaben nützlich sein, bei denen das Programm die meiste Zeit damit verbringt, auf Eingabe-/Ausgangsvorgänge abzuschließen.

Wie kann ich Daten zwischen Prozessen in Python teilen? Dazu gehören die Wert- und Array -Klassen, die die Erstellung gemeinsamer Variablen bzw. Arrays ermöglichen. Es ist jedoch wichtig anzumerken, dass, da jeder Prozess seinen eigenen Speicherplatz hat, Änderungen an gemeinsam genutzten Variablen oder Arrays in einem Prozess in anderen Prozessen nicht reflektiert werden, es sei denn, sie werden mithilfe von Sperren oder anderen Synchronisationsprimitiven explizit synchronisiert.

Was sind die möglichen Fallstricke bei der Verwendung von Multiprozessing in Python? In Python kann die Geschwindigkeit und Effizienz Ihres Programms erheblich verbessern, es wird auch mit eigenen Herausforderungen verbunden. Eine der Hauptverfahren ist die erhöhte Komplexität Ihres Codes. Das Verwalten mehrerer Prozesse kann komplexer sein als das Verwalten eines einsthread-Programms, insbesondere wenn es um die Behandlung gemeinsamer Daten und die Synchronisierungsprozesse geht. Darüber hinaus ist das Erstellen eines neuen Prozesses ressourcenintensiver als das Erstellen eines neuen Threads, was zu einem erhöhten Speicherverbrauch führen kann. Schließlich sind nicht alle Aufgaben für die Parallelisierung geeignet, und in einigen Fällen kann der Aufwand des Erstellens und Verwaltens mehrerer Prozesse die potenziellen Leistungssteigerungen überwiegen. 🎜> Handhabung von Ausnahmen bei der Multiprozessierung in Python kann etwas schwierig sein, da Ausnahmen, die in Kindernprozessen auftreten, nicht auftreten sich automatisch auf den übergeordneten Prozess ausbreiten. Das Multiprocessing -Modul bietet jedoch verschiedene Möglichkeiten, Ausnahmen zu behandeln. Eine Möglichkeit besteht darin, die IS_ALIVE () -Methode der Prozessklasse zu verwenden, um zu überprüfen, ob noch ein Prozess ausgeführt wird. Wenn die Methode false zurückgibt, bedeutet dies, dass der Prozess beendet wurde, was auf eine Ausnahme zurückzuführen ist. Eine andere Möglichkeit besteht darin, das ExitCode -Attribut der Prozessklasse zu verwenden, mit dem weitere Informationen darüber geliefert werden können, warum ein Prozess terminiert ist. Andere Python -Bibliotheken. Es ist jedoch wichtig zu beachten, dass nicht alle Bibliotheken so konzipiert sind, dass sie in einer Multiprozesationsumgebung verwendet werden. Einige Bibliotheken sind möglicherweise nicht threadsicher oder unterstützen möglicherweise nicht die gleichzeitige Ausführung. Daher ist es immer eine gute Idee, die Dokumentation der Bibliothek zu überprüfen, die Sie verwenden, um festzustellen, ob sie die Multiprozessierung unterstützt.

Wie kann ich ein Multiprozessing -Programm in Python debuggen? Es gibt jedoch verschiedene Techniken, mit denen Sie Ihr Programm debuggen können. Eine Möglichkeit besteht darin, Druckanweisungen zu verwenden oder sich anzumelden, um die Ausführung Ihres Programms zu verfolgen. Eine andere Möglichkeit besteht darin, die Funktion des PDB -Moduls set_trace () zu verwenden, um Breakpoints in Ihrem Code festzulegen. Sie können auch spezielle Debugging -Tools verwenden, die die Multiprozessierung unterstützen, z. Betriebssysteme? Das Multiprocessing -Modul ist Teil der Standard -Python -Bibliothek, was bedeutet, dass es auf allen Plattformen erhältlich ist, die Python unterstützen. Das Verhalten des Multiprozessierungsmoduls kann jedoch aufgrund von Unterschieden in der Umgangszahlung mit Prozessen zwischen verschiedenen Betriebssystemen geringfügig variieren. Daher ist es immer eine gute Idee, Ihr Programm auf dem Zielbetriebssystem zu testen, um sicherzustellen, dass es wie erwartet funktioniert. Verwenden der Multiprozessierung in Python gehören:

- Vermeiden Sie die Teilen von Daten zwischen Prozessen, wann immer möglich, da dies zu komplexen Synchronisationsproblemen führen kann. Verwalten Sie Ihre Arbeitsprozesse, da es eine Schnittstelle auf höherer Ebene bietet, die den Prozess des Erstellens und Verwaltens von Prozessen vereinfacht. Das Programm wird fortgesetzt.

- Ausnahmen ordnungsgemäß behandeln, um zu verhindern Umgebung.

Das obige ist der detaillierte Inhalt vonEin Leitfaden zur Python -Multiprocessing und zur parallele Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!