Eine Kurzanleitung zum Python-Multiprocessing-Modul mit Beispielen

Einführung

Mit dem Multiprocessing-Modul in Python können Sie Prozesse erstellen und verwalten und so die Vorteile mehrerer Prozessoren auf einer Maschine voll ausnutzen. Es hilft Ihnen, eine parallele Ausführung zu erreichen, indem für jeden Prozess separate Speicherbereiche verwendet werden, im Gegensatz zum Threading, bei dem Threads denselben Speicherbereich gemeinsam nutzen. Hier ist eine Liste häufig verwendeter Klassen und Methoden im Multiprocessing-Modul mit kurzen Beispielen.

1. Prozess

Die Process-Klasse ist der Kern des Multiprocessing-Moduls und ermöglicht Ihnen das Erstellen und Ausführen neuer Prozesse.

from multiprocessing import Process

def print_numbers():
    for i in range(5):
        print(i)

p = Process(target=print_numbers)
p.start()  # Starts a new process
p.join()   # Waits for the process to finish

2. start()

Startet die Aktivität des Prozesses.

p = Process(target=print_numbers)
p.start()  # Runs the target function in a separate process

3. beitreten([timeout])

Blockiert den aufrufenden Prozess, bis der Prozess, dessen join()-Methode aufgerufen wird, beendet wird. Optional können Sie ein Timeout angeben.

p = Process(target=print_numbers)
p.start()
p.join(2)  # Waits up to 2 seconds for the process to finish

4. is_alive()

Gibt True zurück, wenn der Prozess noch läuft.

p = Process(target=print_numbers)
p.start()
print(p.is_alive())  # True if the process is still running

5. current_process()

Gibt das aktuelle Prozessobjekt zurück, das den aufrufenden Prozess darstellt.

from multiprocessing import current_process

def print_current_process():
    print(current_process())

p = Process(target=print_current_process)
p.start()  # Prints the current process info

6. active_children()

Gibt eine Liste aller aktuell aktiven Prozessobjekte zurück.

p1 = Process(target=print_numbers)
p2 = Process(target=print_numbers)
p1.start()
p2.start()

print(Process.active_children())  # Lists all active child processes

7. cpu_count()

Gibt die Anzahl der auf der Maschine verfügbaren CPUs zurück.

from multiprocessing import cpu_count

print(cpu_count())  # Returns the number of CPUs on the machine

8. Pool

Ein Pool-Objekt bietet eine praktische Möglichkeit, die Ausführung einer Funktion über mehrere Eingabewerte hinweg zu parallelisieren. Es verwaltet einen Pool von Arbeitsprozessen.

from multiprocessing import Pool

def square(n):
    return n * n

with Pool(4) as pool:  # Pool with 4 worker processes
    result = pool.map(square, [1, 2, 3, 4, 5])

print(result)  # [1, 4, 9, 16, 25]

9. Warteschlange

Eine Warteschlange ist eine gemeinsam genutzte Datenstruktur, die es mehreren Prozessen ermöglicht, durch die Weitergabe von Daten zwischen ihnen zu kommunizieren.

from multiprocessing import Process, Queue

def put_data(q):
    q.put([1, 2, 3])

def get_data(q):
    data = q.get()
    print(data)

q = Queue()
p1 = Process(target=put_data, args=(q,))
p2 = Process(target=get_data, args=(q,))

p1.start()
p2.start()
p1.join()
p2.join()

10. Sperren

Eine Sperre stellt sicher, dass jeweils nur ein Prozess auf eine gemeinsam genutzte Ressource zugreifen kann.

from multiprocessing import Process, Lock

lock = Lock()

def print_numbers():
    with lock:
        for i in range(5):
            print(i)

p1 = Process(target=print_numbers)
p2 = Process(target=print_numbers)

p1.start()
p2.start()
p1.join()
p2.join()

11. Wert und Array

Die Value- und Array-Objekte ermöglichen die gemeinsame Nutzung einfacher Datentypen und Arrays zwischen Prozessen.

from multiprocessing import Process, Value

def increment(val):
    with val.get_lock():
        val.value += 1

shared_val = Value('i', 0)
processes = [Process(target=increment, args=(shared_val,)) for _ in range(10)]

for p in processes:
    p.start()

for p in processes:
    p.join()

print(shared_val.value)  # Output will be 10

12. Pfeife

Eine Pipe stellt einen bidirektionalen Kommunikationskanal zwischen zwei Prozessen bereit.

from multiprocessing import Process, Pipe

def send_message(conn):
    conn.send("Hello from child")
    conn.close()

parent_conn, child_conn = Pipe()
p = Process(target=send_message, args=(child_conn,))
p.start()

print(parent_conn.recv())  # Receives data from the child process
p.join()

13. Manager

Mit einem Manager können Sie gemeinsame Objekte wie Listen und Wörterbücher erstellen, die mehrere Prozesse gleichzeitig ändern können.

from multiprocessing import Process, Manager

def modify_list(shared_list):
    shared_list.append("New item")

with Manager() as manager:
    shared_list = manager.list([1, 2, 3])

    p = Process(target=modify_list, args=(shared_list,))
    p.start()
    p.join()

    print(shared_list)  # [1, 2, 3, "New item"]

14. Semaphor

Mit einem Semaphor können Sie den Zugriff auf eine Ressource steuern, sodass nur eine bestimmte Anzahl von Prozessen gleichzeitig darauf zugreifen kann.

from multiprocessing import Process, Semaphore
import time

sem = Semaphore(2)  # Only 2 processes can access the resource

def limited_access():
    with sem:
        print("Accessing resource")
        time.sleep(2)

processes = [Process(target=limited_access) for _ in range(5)]

for p in processes:
    p.start()

for p in processes:
    p.join()

Abschluss

Das Multiprocessing-Modul in Python ist darauf ausgelegt, die Vorteile mehrerer Prozessoren auf einer Maschine voll auszunutzen. Von der Erstellung und Verwaltung von Prozessen mit Process über die Steuerung gemeinsam genutzter Ressourcen mit Lock und Semaphore bis hin zur Erleichterung der Kommunikation über Queue und Pipe ist das Multiprocessing-Modul für die Parallelisierung von Aufgaben in Python-Anwendungen von entscheidender Bedeutung.

Das obige ist der detaillierte Inhalt vonEine Kurzanleitung zum Python-Multiprocessing-Modul mit Beispielen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!