Python Multiprocessing für parallele Ausführung

Einführung

Python Multiprocessing ist ein leistungsstarkes Tool, das die Ausführung von Python-Programmen, die hohe Rechenleistung erfordern, erheblich beschleunigen kann. In diesem Lab werden Sie über Python Multiprocessing und die Verwendung dazu, Prozesse parallel auszuführen, lernen. Wir beginnen mit einfachen Beispielen und gelangen schrittweise zu komplexeren.

Erstellen eines einfachen Multiprocessing-Programms

Der erste Schritt beim Lernen von Multiprocessing in Python besteht darin, ein einfaches Programm zu erstellen, das zeigt, wie es funktioniert. In diesem Programm werden wir eine Funktion erstellen, die ein einzelnes Argument annimmt und das Quadrat dieser Zahl zurückgibt. Anschließend werden wir Multiprocessing verwenden, um diese Funktion auf mehreren Prozessen auszuführen.

Bitte vervollständigen Sie square.py.

import multiprocessing

def square(x):
    return x * x

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = pool.map(square, range(10))
    print(results)

Dieser Code erstellt einen Pool von vier Prozessen und verwendet die map()-Funktion, um die square()-Funktion auf jede der Zahlen im Bereich von 0 bis 9 anzuwenden. Die Ergebnisse werden dann in der Konsole ausgegeben.

Verwenden von Multiprocessing, um die Verarbeitung zu beschleunigen

Jetzt, da Sie verstehen, wie Multiprocessing in Python funktioniert, können wir zu einem komplexeren Beispiel übergehen. In diesem Beispiel werden wir Multiprocessing verwenden, um die Verarbeitung einer großen Liste von Zahlen zu beschleunigen.

Bitte vervollständigen Sie complex_square.py.

import multiprocessing

def square(x):
    return x * x

if __name__ == '__main__':
    with multiprocessing.Pool(processes=4) as pool:
        results = pool.map(square, range(1000000))
    print(results[:10])

Dieser Code erstellt einen Pool von vier Prozessen und verwendet die map()-Funktion, um die square()-Funktion auf jede der Zahlen im Bereich von 0 bis 999999 anzuwenden. Die with-Anweisung wird verwendet, um sicherzustellen, dass der Prozesspool richtig geschlossen wird, wenn die Verarbeitung abgeschlossen ist. Die ersten zehn Ergebnisse werden dann in der Konsole ausgegeben.

Inter-Prozesskommunikation

In einigen Fällen müssen Sie bei der Verwendung von Multiprocessing in Python zwischen Prozessen kommunizieren. In diesem Beispiel verwenden wir die multiprocessing.Queue()-Funktion, um eine gemeinsame Warteschlange zwischen Prozessen zu erstellen.

Bitte vervollständigen Sie multiprocessing_queue.py.

import multiprocessing

def producer(queue):
    for i in range(10):
        queue.put(i)

def consumer(queue):
    while True:
        item = queue.get()
        if item is None:
            break
        print(item)

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    process_producer = multiprocessing.Process(target=producer, args=(queue,))
    process_consumer = multiprocessing.Process(target=consumer, args=(queue,))
    process_producer.start()
    process_consumer.start()
    process_producer.join()
    queue.put(None)
    process_consumer.join()

Dieser Code erstellt eine gemeinsame Warteschlange queue mit der multiprocessing.Queue()-Funktion. Anschließend erstellen wir zwei Prozesse, die jeweils eine Funktion producer() und consumer() aufrufen. Die producer()-Funktion legt die Zahlen von 0 bis 9 in die Warteschlange, während die consumer()-Funktion jedes Element aus der Warteschlange holt und es in der Konsole ausgibt.

Asynchrone Aufgaben mit Pool.apply_async()

Neben map() bietet die multiprocessing.Pool()-Klasse eine andere Methode zum parallelen Ausführen von Prozessen, nämlich apply_async(). Mit dieser Methode können Sie einen Funktionsaufruf an einen Prozesspool übermitteln und sofort fortfahren, ohne auf das Ergebnis zu warten. Stattdessen können Sie eine Callback-Funktion verwenden, um das Ergebnis des Funktionsaufrufs abzurufen, wenn es bereit ist.

Bitte vervollständigen Sie slow_square.py.

import multiprocessing
import time

def slow_square(x):
    time.sleep(1)
    return x * x

def callback(result):
    print(result)

if __name__ == '__main__':
    pool = multiprocessing.Pool(processes=4)
    results = [pool.apply_async(slow_square, (x,), callback=callback) for x in range(10)]
    for result in results:
        result.wait()
    print("All tasks completed.")

In diesem Beispiel definieren wir eine Funktion slow_square(), die eine Zahl x annimmt, eine Sekunde wartet und dann das Quadrat von x zurückgibt. Wir definieren auch eine Callback-Funktion callback(), die einfach das Ergebnis ausgibt, wenn es verfügbar ist.

Anschließend erstellen wir einen Prozesspool mit vier Prozessen und verwenden apply_async(), um für jede Zahl im Bereich von 0 bis 9 einen Funktionsaufruf an den Pool zu übermitteln. Wir übergeben die slow_square()-Funktion und das Argument x über den args-Parameter und geben auch die Callback-Funktion an, die aufgerufen werden soll, wenn das Ergebnis bereit ist.

Wir durchlaufen dann die Liste der Ergebnisse und rufen result.wait() auf, um den Hauptthread zu blockieren, bis das Ergebnis bereit ist. Schließlich geben wir eine Nachricht aus, um anzuzeigen, dass alle Aufgaben abgeschlossen sind.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Python Multiprocessing verwenden, um Prozesse parallel auszuführen. Sie haben mit einem einfachen Programm begonnen, das gezeigt hat, wie Multiprocessing funktioniert, und sind dann zu komplexeren Beispielen übergegangen, bei denen Multiprocessing verwendet wurde, um die Verarbeitung zu beschleunigen, den Arbeitsspeicher zwischen Prozessen zu teilen und asynchrone Aufgaben mit apply_async() auszuführen. Am Ende dieses Labs sollten Sie eine gute Vorstellung davon haben, wie Sie Multiprocessing in Ihren eigenen Python-Programmen verwenden, um eine höhere Verarbeitungsleistung und Effizienz zu erreichen und zwischen Prozessen zu kommunizieren, wenn dies erforderlich ist.