Python Academy · Lektion

Grundlagen von multiprocessing

Mehrere CPU-Kerne verwenden

Grundlagen von multiprocessing ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum multiprocessing?

Der GIL verhindert, dass Threads Python-Bytecode parallel ausführen. Das Modul multiprocessing umgeht diese Einschränkung, indem es separate Prozesse startet, von denen jeder seinen eigenen Interpreter und GIL besitzt. Dadurch kann CPU-intensive Arbeit tatsächlich auf mehreren Kernen ausgeführt werden.

import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())

Einen Prozess starten

Process(target=func) bildet die threading-API nach. Rufen Sie start() zum Starten und join() zum Warten auf.

import multiprocessing as mp

def worker():
    print('hello from a child process')

if __name__ == '__main__':
    p = mp.Process(target=worker)
    p.start()
    p.join()
    print('parent done')

Der main-Guard

Auf manchen Plattformen importieren Kindprozesse Ihr Skript. Ohne einen if __name__ == '__main__':-Guard können Sie Prozesse rekursiv starten. Umschließen Sie den Startcode immer damit.

import multiprocessing as mp

def task(n):
    print('processing', n)

if __name__ == '__main__':
    for i in range(3):
        p = mp.Process(target=task, args=(i,))
        p.start()
        p.join()

Argumente übergeben

Verwenden Sie wie bei Threads args für Positionsargumente und kwargs für Schlüsselwortargumente. Die Argumente werden per Pickle serialisiert und an den Kindprozess gesendet.

import multiprocessing as mp

def show(label, times):
    for _ in range(times):
        print(label)

if __name__ == '__main__':
    p = mp.Process(target=show, args=('hi',), kwargs={'times': 2})
    p.start()
    p.join()

Ein Pool von Workern

multiprocessing.Pool verwaltet eine Gruppe von Prozessen. pool.map verteilt ein Iterable auf diese Prozesse und sammelt die Ergebnisse in der ursprünglichen Reihenfolge.

import multiprocessing as mp

def square(n):
    return n * n

if __name__ == '__main__':
    with mp.Pool(processes=2) as pool:
        print(pool.map(square, range(6)))

ProcessPoolExecutor

Die API concurrent.futures bietet auch ProcessPoolExecutor mit derselben submit-/map-Schnittstelle, die Sie bereits für Threads kennengelernt haben.

from concurrent.futures import ProcessPoolExecutor

def cube(n):
    return n ** 3

if __name__ == '__main__':
    with ProcessPoolExecutor() as ex:
        print(list(ex.map(cube, range(5))))

Getrennte Speicherbereiche

Jeder Prozess verfügt über seinen eigenen Speicher. Wenn ein Kindprozess eine globale Variable ändert, ändert das nicht die Kopie im Elternprozess. Daten müssen ausdrücklich zurückgegeben oder gemeinsam genutzt werden.

import multiprocessing as mp

counter = 0

def bump():
    global counter
    counter += 100

if __name__ == '__main__':
    p = mp.Process(target=bump)
    p.start()
    p.join()
    print('parent counter still:', counter)

Ergebnisse zurückerhalten

Da der Speicher nicht gemeinsam genutzt wird, geben Sie Ergebnisse über Pool.map, Executor oder Queues zurück, statt globale Variablen zu verändern.

import multiprocessing as mp

def double(n):
    return n * 2

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        results = pool.map(double, [1, 2, 3, 4])
    print('results:', results)

apply_async für einzelne Aufrufe

apply_async plant einen einzelnen Aufruf und gibt ein Ergebnis-Handle zurück. Rufen Sie .get() auf, um den Wert abzurufen.

import multiprocessing as mp

def add(a, b):
    return a + b

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        r = pool.apply_async(add, (3, 4))
        print(r.get())

Anforderung an Pickling

Ziele und Argumente müssen picklbar sein, damit sie die Prozessgrenze überschreiten können. Top-Level-Funktionen funktionieren; Lambdas und lokale Funktionen normalerweise nicht.

import multiprocessing as mp

def top_level(n):
    return n + 1

if __name__ == '__main__':
    with mp.Pool(2) as pool:
        print(pool.map(top_level, [10, 20]))

Wann Sie Prozesse verwenden sollten

Verwenden Sie Prozesse für CPU-bound-Aufgaben wie Berechnungen, Bildverarbeitung oder Parsing. Der Aufwand für das Starten von Prozessen und das Pickling bedeutet, dass sie sich eher für wenige, umfangreichere Aufgaben als für viele winzige Aufgaben eignen.

import multiprocessing as mp

def heavy(n):
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with mp.Pool() as pool:
        print(pool.map(heavy, [1000, 2000, 3000]))

Kurztest

Testen Sie Ihr Verständnis von multiprocessing.

Rückblick

Sie haben die Grundlagen von multiprocessing kennengelernt:

Prozesse umgehen den GIL und ermöglichen echten CPU-Parallelismus.
Verwenden Sie den if __name__ == '__main__'-Guard.
Pool und ProcessPoolExecutor verteilen Arbeit und sammeln Ergebnisse.
Der Speicher wird nicht gemeinsam genutzt; Argumente müssen picklbar sein.

Als Nächstes: Daten sicher mit Queues und Locks gemeinsam nutzen.

Häufig gestellte Fragen

Ist die Lektion „Grundlagen von multiprocessing“ kostenlos?

Ja — der vollständige Text von „Grundlagen von multiprocessing“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Grundlagen von multiprocessing“?

Mehrere CPU-Kerne verwenden Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Grundlagen von multiprocessing“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Python Academy