Python Multiprocessing: Parallele Verarbeitung von Prozessen

Mit Python Multiprocessing können Sie die Arbeitslast auf mehrere Prozesse aufteilen, um die Gesamtausführungszeit zu verkürzen. Das ist besonders vorteilhaft bei umfangreichen Berechnungen oder großen Datenmengen.

Was ist Python Multiprocessing?

Multiprocessing in Python bezeichnet die Fähigkeit, mehrere Prozesse gleichzeitig auszuführen, wodurch die Leistung von Multi-Core-Systemen optimal genutzt wird. Im Gegensatz zu Single-Thread-Ansätzen, bei denen Aufgaben sequenziell abgearbeitet werden, können mit Multiprocessing verschiedene Teile des Programms parallel und unabhängig voneinander ablaufen. Jeder Prozess verfügt über einen eigenen Speicherbereich und kann auf separaten Prozessorkernen verarbeitet werden, wodurch sich die Ausführungszeit für rechenaufwendige oder zeitkritische Operationen erheblich reduziert.

Die Einsatzgebiete von Python Multiprocessing sind vielfältig. In der Datenverarbeitung und Analyse wird Multiprocessing häufig verwendet, um große Datensätze schneller zu verarbeiten und komplexe Analysen zu beschleunigen. Auch in Simulationen und Modellierungsberechnungen, beispielsweise in wissenschaftlichen Anwendungen, kann Multiprocessing eingesetzt werden, um die Ausführungszeiten von komplexen Berechnungen zu verkürzen. Darüber hinaus findet Multiprocessing Anwendung im Bereich des Web-Scrapings für die gleichzeitige Erfassung von Daten von verschiedenen Webseiten oder in der Bildverarbeitung sowie Computer Vision, um die Effizienz von Operationen zur Bildanalyse zu verbessern.

Welche Möglichkeiten für Python Multiprocessing gibt es?

Python bietet verschiedene Möglichkeiten, Multiprocessing zu implementieren. Im Folgenden stellen wir Ihnen drei gängige Tools vor: das multiprocessing-Modul, die concurrent.futures-Bibliothek und das joblib-Paket.

Das multiprocessing-Modul

Das multiprocessing-Modul ist das Standardmodul für Python Multiprocessing. Es ermöglicht die Erstellung von Prozessen, den Austausch von Daten zwischen diesen Prozessen und die Synchronisierung durch Sperren, Warteschlangen und andere Mechanismen.

import multiprocessing
def task(n):
    result = n * n
    print(f"Result: {result}")
if __name__ == "__main__":
    processes = []
    for i in range(1, 6):
        process = multiprocessing.Process(target=task, args=(i,))
        processes.append(process)
        process.start()
    for process in processes:
        process.join()

Im obigen Beispiel benutzen wir die Klasse multiprocessing.Process, um Prozesse zu erstellen und zu starten, die die Funktion task() ausführen. Diese berechnet das Quadrat der übergebenen Zahl. Die Prozesse werden initiiert und es wird auf ihre Beendigung gewartet, bevor das Hauptprogramm fortgesetzt wird. Das Ergebnis geben wir mit einem f-String aus, eine Python-String-Format-Methode zum Verknüpfen von Ausdrücken. Die Reihenfolge ist zufällig und nicht deterministisch.

Sie können auch einen Prozesspool mit Python multiprocessing erzeugen:

import multiprocessing
def task(n):
    return n * n
if __name__ == "__main__":
    with multiprocessing.Pool() as pool:
        results = pool.map(task, range(1, 6))
        print(results)  # Output: [1, 4, 9, 16, 25]

Mit pool.map() wird die Funktion task() auf eine Sequenz von Daten angewendet, und die Ergebnisse werden gesammelt und ausgegeben.

Die concurrent.futures-Bibliothek

Dieses Modul bietet eine High-Level-Schnittstelle für eine asynchrone Durchführung und parallele Verarbeitung von Prozessen. Es verwendet den Pool-Executor, um Aufgaben auf einem Pool von Prozessen oder Threads auszuführen. Das concurrent.futures-Modul ist eine einfachere Möglichkeit, asynchrone Aufgaben zu verarbeiten, und ist in vielen Fällen leichter zu handhaben als das Python multiprocessing-Modul.

import concurrent.futures
def task(n):
    return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
    futures = [executor.submit(task, i) for i in range(1, 6)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result()) # result in random order

Der Code nutzt das concurrent.futures-Modul, um Aufgaben parallel mit dem ProcessPoolExecutor abzuarbeiten. Dabei wird die Funktion task(n) für Zahlen von 1 bis 5 übergeben. Die as_completed()-Methode wartet auf den Abschluss der Aufgaben und gibt die Ergebnisse in beliebiger Reihenfolge aus.

joblib

joblib ist eine externe Python-Bibliothek, die entwickelt wurde, um die Parallelverarbeitung in Python zu vereinfachen, zum Beispiel für wiederholbare Aufgaben wie das Ausführen von Funktionen mit unterschiedlichen Eingangsparametern oder das Arbeiten mit großen Datenmengen. Die Hauptfunktionen von joblib konzentrieren sich auf die Parallelisierung von Aufgaben, das Zwischenspeichern (Caching) von Funktionsergebnissen und die Optimierung von Speicher- und Rechenressourcen.

from joblib import Parallel, delayed
def task(n):
    return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: Results of the function for numbers from 1 to 10

Der Ausdruck Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) initiiert die parallele Ausführung der Funktion task() für die Zahlen von 1 bis 10. Parallel wird mit n_jobs=4 konfiguriert, was dazu führt, dass bis zu vier parallele Jobs verarbeitet werden können. Der Aufruf von delayed(task)(i) erstellt die parallel durchzuführende Aufgabe für jede Zahl i im Bereich von 1 bis 10. Dies bedeutet, dass die Funktion task() gleichzeitig für jede dieser Zahlen aufgerufen wird. Das Ergebnis für die Zahlen von 1 bis 10 wird in results gespeichert und ausgegeben.