Concurrency in Python freischalten: ThreadPoolExecutor vs. ProcessPoolExecutor

Python ist zwar eine vielseitige und weit verbreitete Programmiersprache, hat aber aufgrund des Global Interpreter Lock (GIL) bestimmte Einschränkungen hinsichtlich echter Parallelität. Das Modul concurrent.futures bietet eine High-Level-Schnittstelle zur asynchronen Ausführung von Aufrufbaren und bietet eine Möglichkeit, einige dieser Einschränkungen zu umgehen und die Leistung für bestimmte Aufgabentypen zu verbessern. Dieses Modul bietet zwei Schlüsselklassen: ThreadPoolExecutor und ProcessPoolExecutor. Dieser umfassende Leitfaden wird beide untersuchen, ihre Unterschiede, Stärken und Schwächen hervorheben und praktische Beispiele liefern, die Ihnen helfen, den richtigen Executor für Ihre Bedürfnisse auszuwählen.

Konkurrenz und Parallelität verstehen

Bevor wir uns mit den Besonderheiten jedes Executors befassen, ist es wichtig, die Konzepte der Konkurrenz und Parallelität zu verstehen. Diese Begriffe werden oft austauschbar verwendet, haben aber unterschiedliche Bedeutungen:

• Konkurrenz: Bezieht sich auf die gleichzeitige Verwaltung mehrerer Aufgaben. Es geht darum, Ihren Code so zu strukturieren, dass mehrere Dinge scheinbar gleichzeitig gehandhabt werden, auch wenn sie auf einem einzigen Prozessorkern tatsächlich verschachtelt sind. Stellen Sie es sich wie einen Koch vor, der mehrere Töpfe auf einem einzigen Herd verwaltet – sie kochen nicht alle im genauen selben Moment, aber der Koch verwaltet sie alle.
• Parallelität: Bezieht sich auf die tatsächliche gleichzeitige Ausführung mehrerer Aufgaben, typischerweise durch die Nutzung mehrerer Prozessorkerne. Dies ist vergleichbar mit mehreren Köchen, die gleichzeitig an verschiedenen Teilen der Mahlzeit arbeiten.

Pythons GIL verhindert weitgehend echte Parallelität für CPU-gebundene Aufgaben bei der Verwendung von Threads. Das liegt daran, dass der GIL nur einem Thread zu einem bestimmten Zeitpunkt die Kontrolle über den Python-Interpreter erlaubt. Für E/A-gebundene Aufgaben, bei denen das Programm die meiste Zeit mit dem Warten auf externe Operationen wie Netzwerkanfragen oder Festplattenlesen verbringt, können Threads dennoch erhebliche Leistungsverbesserungen erzielen, indem sie anderen Threads die Ausführung ermöglichen, während einer wartet.

Das Modul `concurrent.futures` vorstellen

Das Modul concurrent.futures vereinfacht den Prozess der asynchronen Ausführung von Aufgaben. Es bietet eine High-Level-Schnittstelle zur Arbeit mit Threads und Prozessen und abstrahiert einen Großteil der Komplexität, die mit ihrer direkten Verwaltung verbunden ist. Das Kernkonzept ist der "Executor", der die Ausführung übermittelter Aufgaben verwaltet. Die beiden primären Executors sind:

• ThreadPoolExecutor: Nutzt einen Thread-Pool zur Ausführung von Aufgaben. Geeignet für E/A-gebundene Aufgaben.
• ProcessPoolExecutor: Nutzt einen Prozess-Pool zur Ausführung von Aufgaben. Geeignet für CPU-gebundene Aufgaben.

ThreadPoolExecutor: Threads für E/A-gebundene Aufgaben nutzen

Der ThreadPoolExecutor erstellt einen Pool von Worker-Threads zur Ausführung von Aufgaben. Aufgrund des GIL sind Threads für rechenintensive Operationen, die von echter Parallelität profitieren, nicht ideal. Sie eignen sich jedoch hervorragend für E/A-gebundene Szenarien. Lassen Sie uns untersuchen, wie er verwendet wird:

Grundlegende Verwendung

Hier ist ein einfaches Beispiel für die Verwendung von ThreadPoolExecutor zum gleichzeitigen Herunterladen mehrerer Webseiten:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Löst HTTPError für ungültige Antworten aus (4xx oder 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Jede URL dem Executor übermitteln
    futures = [executor.submit(download_page, url) for url in urls]

    # Warten, bis alle Aufgaben abgeschlossen sind
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

Erklärung:

1. Wir importieren die notwendigen Module: concurrent.futures, requests und time.
2. Wir definieren eine Liste von URLs zum Herunterladen.
3. Die Funktion download_page ruft den Inhalt einer gegebenen URL ab. Fehlerbehandlung ist mithilfe von try...except und response.raise_for_status() enthalten, um potenzielle Netzwerkprobleme abzufangen.
4. Wir erstellen einen ThreadPoolExecutor mit maximal 4 Worker-Threads. Das Argument max_workers steuert die maximale Anzahl von Threads, die gleichzeitig verwendet werden können. Ein zu hoher Wert verbessert die Leistung möglicherweise nicht immer, insbesondere bei E/A-gebundenen Aufgaben, bei denen die Netzwerkbandbreite oft der Engpass ist.
5. Wir verwenden eine Listen-Abstraktion, um jede URL über executor.submit(download_page, url) dem Executor zu übermitteln. Dies gibt für jede Aufgabe ein Future-Objekt zurück.
6. Die Funktion concurrent.futures.as_completed(futures) gibt einen Iterator zurück, der Futures liefert, sobald sie abgeschlossen sind. Dies vermeidet das Warten auf den Abschluss aller Aufgaben, bevor Ergebnisse verarbeitet werden.
7. Wir iterieren durch die abgeschlossenen Futures und rufen das Ergebnis jeder Aufgabe über future.result() ab, wobei die insgesamt heruntergeladenen Bytes summiert werden. Die Fehlerbehandlung innerhalb von download_page stellt sicher, dass einzelne Fehler den gesamten Prozess nicht zum Absturz bringen.
8. Schließlich geben wir die insgesamt heruntergeladenen Bytes und die benötigte Zeit aus.

Vorteile von ThreadPoolExecutor

• Vereinfachte Konkurrenz: Bietet eine saubere und einfach zu bedienende Schnittstelle zur Verwaltung von Threads.
• Leistung bei E/A-gebundenen Aufgaben: Hervorragend geeignet für Aufgaben, die viel Zeit mit dem Warten auf E/A-Operationen verbringen, wie Netzwerkanfragen, Dateilesevorgänge oder Datenbankabfragen.
• Geringer Overhead: Threads haben im Allgemeinen einen geringeren Overhead als Prozesse, was sie für Aufgaben, die häufige Kontextwechsel beinhalten, effizienter macht.

Einschränkungen von ThreadPoolExecutor

• GIL-Beschränkung: Der GIL schränkt echte Parallelität für CPU-gebundene Aufgaben ein. Nur ein Thread kann gleichzeitig Python-Bytecode ausführen, was die Vorteile mehrerer Kerne zunichte macht.
• Debugging-Komplexität: Das Debugging von Multithreaded-Anwendungen kann aufgrund von Race Conditions und anderen Konkurrenz-bezogenen Problemen schwierig sein.

ProcessPoolExecutor: Multiprocessing für CPU-gebundene Aufgaben entfesseln

Der ProcessPoolExecutor umgeht die GIL-Beschränkung, indem er einen Pool von Worker-Prozessen erstellt. Jeder Prozess hat seinen eigenen Python-Interpreter und Speicherbereich, was echte Parallelität auf Multi-Core-Systemen ermöglicht. Dies macht ihn ideal für CPU-gebundene Aufgaben, die intensive Berechnungen beinhalten.

Grundlegende Verwendung

Betrachten Sie eine rechenintensive Aufgabe wie die Berechnung der Summe der Quadrate für einen großen Zahlenbereich. Hier ist, wie ProcessPoolExecutor verwendet wird, um diese Aufgabe zu parallelisieren:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Wichtig, um rekursives Erzeugen in einigen Umgebungen zu vermeiden
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

Erklärung:

1. Wir definieren die Funktion sum_of_squares, die die Summe der Quadrate für einen gegebenen Zahlenbereich berechnet. Wir fügen os.getpid() hinzu, um zu sehen, welcher Prozess jeden Bereich ausführt.
2. Wir definieren die Bereichsgröße und die Anzahl der zu verwendenden Prozesse. Die Liste ranges wird erstellt, um den gesamten Berechnungsbereich in kleinere Blöcke zu unterteilen, einen für jeden Prozess.
3. Wir erstellen einen ProcessPoolExecutor mit der angegebenen Anzahl von Worker-Prozessen.
4. Wir übermitteln jeden Bereich über executor.submit(sum_of_squares, start, end) an den Executor.
5. Wir sammeln die Ergebnisse aus jedem Future über future.result().
6. Wir summieren die Ergebnisse aller Prozesse, um die endgültige Summe zu erhalten.

Wichtiger Hinweis: Bei der Verwendung von ProcessPoolExecutor, insbesondere unter Windows, sollten Sie den Code, der den Executor erstellt, in einen if __name__ == "__main__":-Block einschließen. Dies verhindert rekursives Prozess-Erzeugen, das zu Fehlern und unerwartetem Verhalten führen kann. Dies liegt daran, dass das Modul in jedem Kindprozess neu importiert wird.

Vorteile von ProcessPoolExecutor

• Echte Parallelität: Umgeht die GIL-Beschränkung und ermöglicht echte Parallelität auf Multi-Core-Systemen für CPU-gebundene Aufgaben.
• Verbesserte Leistung für CPU-gebundene Aufgaben: Bei rechenintensiven Operationen können erhebliche Leistungssteigerungen erzielt werden.
• Robustheit: Wenn ein Prozess abstürzt, bringt dies nicht unbedingt das gesamte Programm zum Absturz, da Prozesse voneinander isoliert sind.

Einschränkungen von ProcessPoolExecutor

• Höherer Overhead: Das Erstellen und Verwalten von Prozessen hat einen höheren Overhead im Vergleich zu Threads.
• Interprozesskommunikation: Das Teilen von Daten zwischen Prozessen kann komplexer sein und erfordert Mechanismen zur Interprozesskommunikation (IPC), die zusätzlichen Overhead verursachen können.
• Speicherbedarf: Jeder Prozess hat seinen eigenen Speicherbereich, was den gesamten Speicherbedarf der Anwendung erhöhen kann. Die Übergabe großer Datenmengen zwischen Prozessen kann zum Engpass werden.

Den richtigen Executor wählen: ThreadPoolExecutor vs. ProcessPoolExecutor

Der Schlüssel zur Wahl zwischen ThreadPoolExecutor und ProcessPoolExecutor liegt im Verständnis der Art Ihrer Aufgaben:

• E/A-gebundene Aufgaben: Wenn Ihre Aufgaben die meiste Zeit mit dem Warten auf E/A-Operationen (z. B. Netzwerkanfragen, Dateilesevorgänge, Datenbankabfragen) verbringen, ist ThreadPoolExecutor im Allgemeinen die bessere Wahl. Der GIL ist in diesen Szenarien weniger ein Engpass, und der geringere Overhead von Threads macht sie effizienter.
• CPU-gebundene Aufgaben: Wenn Ihre Aufgaben rechenintensiv sind und mehrere Kerne nutzen, ist ProcessPoolExecutor die richtige Wahl. Er umgeht die GIL-Beschränkung und ermöglicht echte Parallelität, was zu erheblichen Leistungsverbesserungen führt.

Hier ist eine Tabelle, die die Hauptunterschiede zusammenfasst:

Merkmal	ThreadPoolExecutor	ProcessPoolExecutor
Konkurrenzmodell	Multithreading	Multiprocessing
GIL-Auswirkung	Durch GIL begrenzt	Umgeht GIL
Geeignet für	E/A-gebundene Aufgaben	CPU-gebundene Aufgaben
Overhead	Niedriger	Höher
Speicherbedarf	Niedriger	Höher
Interprozesskommunikation	Nicht erforderlich (Threads teilen sich den Speicher)	Erforderlich für den Datenaustausch
Robustheit	Weniger robust (ein Absturz kann den gesamten Prozess beeinträchtigen)	Robuster (Prozesse sind isoliert)

Fortgeschrittene Techniken und Überlegungen

Aufgaben mit Argumenten übermitteln

Beide Executors ermöglichen es Ihnen, Argumente an die auszuführende Funktion zu übergeben. Dies geschieht über die Methode submit():

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

Ausnahmen behandeln

Ausnahmen, die innerhalb der ausgeführten Funktion ausgelöst werden, werden nicht automatisch an den Hauptthread oder -prozess weitergegeben. Sie müssen sie beim Abrufen des Ergebnisses des Future explizit behandeln:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

`map` für einfache Aufgaben verwenden

Für einfache Aufgaben, bei denen Sie dieselbe Funktion auf eine Eingabesequenz anwenden möchten, bietet die Methode map() eine prägnante Möglichkeit, Aufgaben zu übermitteln:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

Anzahl der Worker steuern

Das Argument max_workers in sowohl ThreadPoolExecutor als auch ProcessPoolExecutor steuert die maximale Anzahl von Threads oder Prozessen, die gleichzeitig verwendet werden können. Die Auswahl des richtigen Werts für max_workers ist wichtig für die Leistung. Ein guter Ausgangspunkt ist die Anzahl der auf Ihrem System verfügbaren CPU-Kerne. Bei E/A-gebundenen Aufgaben können Sie jedoch von der Verwendung von mehr Threads als Kernen profitieren, da Threads auf andere Aufgaben umschalten können, während sie auf E/A warten. Experimentieren und Profiling sind oft notwendig, um den optimalen Wert zu ermitteln.

Fortschritt überwachen

Das Modul concurrent.futures bietet keine integrierten Mechanismen zur direkten Überwachung des Fortschritts von Aufgaben. Sie können jedoch Ihre eigene Fortschrittsverfolgung implementieren, indem Sie Rückrufe oder freigegebene Variablen verwenden. Bibliotheken wie tqdm können integriert werden, um Fortschrittsbalken anzuzeigen.

Reale Beispiele

Betrachten wir einige reale Szenarien, in denen ThreadPoolExecutor und ProcessPoolExecutor effektiv eingesetzt werden können:

• Web Scraping: Paralleles Herunterladen und Parsen mehrerer Webseiten mit ThreadPoolExecutor. Jeder Thread kann eine andere Webseite verarbeiten, was die gesamte Scraping-Geschwindigkeit verbessert. Achten Sie auf die Nutzungsbedingungen von Websites und vermeiden Sie es, deren Server zu überlasten.
• Bildverarbeitung: Anwenden von Bildfiltern oder Transformationen auf eine große Anzahl von Bildern mit ProcessPoolExecutor. Jeder Prozess kann ein anderes Bild verarbeiten und mehrere Kerne für eine schnellere Verarbeitung nutzen. Berücksichtigen Sie Bibliotheken wie OpenCV für eine effiziente Bildbearbeitung.
• Datenanalyse: Durchführen komplexer Berechnungen an großen Datensätzen mit ProcessPoolExecutor. Jeder Prozess kann einen Teil der Daten analysieren, was die Gesamtanalysezeit verkürzt. Pandas und NumPy sind beliebte Bibliotheken für die Datenanalyse in Python.
• Maschinelles Lernen: Trainieren von Modellen für maschinelles Lernen mit ProcessPoolExecutor. Einige Algorithmen für maschinelles Lernen können effektiv parallelisiert werden, was zu schnelleren Trainingszeiten führt. Bibliotheken wie scikit-learn und TensorFlow bieten Unterstützung für Parallelisierung.
• Videokodierung: Konvertieren von Videodateien in verschiedene Formate mit ProcessPoolExecutor. Jeder Prozess kann ein anderes Videosegment kodieren, was den gesamten Kodierungsprozess beschleunigt.

Globale Überlegungen

Bei der Entwicklung von konzerngeschäftigen Anwendungen für ein globales Publikum ist es wichtig, die folgenden Punkte zu berücksichtigen:

• Zeitzonen: Berücksichtigen Sie bei der Verarbeitung zeitkritischer Operationen Zeitzonen. Verwenden Sie Bibliotheken wie pytz, um Zeitzonenkonvertierungen durchzuführen.
• Lokalisierung: Stellen Sie sicher, dass Ihre Anwendung verschiedene Lokalisierungen korrekt verarbeitet. Verwenden Sie Bibliotheken wie locale, um Zahlen, Daten und Währungen entsprechend der Lokalisierung des Benutzers zu formatieren.
• Zeichenkodierungen: Verwenden Sie Unicode (UTF-8) als Standardzeichenkodierung, um eine Vielzahl von Sprachen zu unterstützen.
• Internationalisierung (i18n) und Lokalisierung (l10n): Entwerfen Sie Ihre Anwendung so, dass sie einfach internationalisiert und lokalisiert werden kann. Verwenden Sie gettext oder andere Übersetzungsbibliotheken, um Übersetzungen für verschiedene Sprachen bereitzustellen.
• Netzwerklatenz: Berücksichtigen Sie die Netzwerklatenz bei der Kommunikation mit entfernten Diensten. Implementieren Sie geeignete Timeouts und Fehlerbehandlung, um sicherzustellen, dass Ihre Anwendung resistent gegen Netzwerkprobleme ist. Der geografische Standort von Servern kann die Latenz erheblich beeinflussen. Erwägen Sie die Verwendung von Content Delivery Networks (CDNs), um die Leistung für Benutzer in verschiedenen Regionen zu verbessern.

Fazit

Das Modul concurrent.futures bietet eine leistungsstarke und bequeme Möglichkeit, Konkurrenz und Parallelität in Ihre Python-Anwendungen zu integrieren. Indem Sie die Unterschiede zwischen ThreadPoolExecutor und ProcessPoolExecutor verstehen und die Art Ihrer Aufgaben sorgfältig berücksichtigen, können Sie die Leistung und Reaktionsfähigkeit Ihres Codes erheblich verbessern. Denken Sie daran, Ihren Code zu profilieren und mit verschiedenen Konfigurationen zu experimentieren, um die optimalen Einstellungen für Ihren spezifischen Anwendungsfall zu finden. Seien Sie sich auch der Einschränkungen des GIL und der potenziellen Komplexitäten der Multithreading- und Multiprocessing-Programmierung bewusst. Mit sorgfältiger Planung und Implementierung können Sie das volle Potenzial der Konkurrenz in Python freischalten und robuste und skalierbare Anwendungen für ein globales Publikum erstellen.