Basisprincipes van multiprocessing
Gebruik meerdere CPU-kernen
Basisprincipes van multiprocessing is een gratis Python Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.
Waarom multiprocessing?
De GIL voorkomt dat threads Python-bytecode parallel uitvoeren. De module multiprocessing omzeilt dit door afzonderlijke processen te starten, elk met een eigen interpreter en GIL, zodat CPU-gebonden werk echt op meerdere kernen wordt uitgevoerd.
import multiprocessing as mp
print('CPU cores available:', mp.cpu_count())Een proces starten
Process(target=func) werkt op dezelfde manier als de API voor threading. Roep start() aan om het proces te starten en join() om te wachten.
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')De beveiliging voor __main__
Op sommige platforms importeren onderliggende processen je script. Zonder een if __name__ == '__main__':-beveiliging kun je processen recursief blijven starten. Plaats de startcode altijd hierin.
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()Argumenten doorgeven
Gebruik args voor positionele argumenten en kwargs voor benoemde argumenten, net als bij threads. Argumenten worden met pickle geserialiseerd en naar het onderliggende proces gestuurd.
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()Een pool met werkprocessen
multiprocessing.Pool beheert een groep processen. pool.map verdeelt een itereerbaar object over deze processen en verzamelt de resultaten in volgorde.
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
De API concurrent.futures biedt ook ProcessPoolExecutor, met dezelfde interface voor submit/map die je bij threads hebt gezien.
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))))Afzonderlijke geheugenruimten
Elk proces heeft zijn eigen geheugen. Het wijzigen van een globale variabele in een onderliggend proces verandert de kopie van het bovenliggende proces niet. Gegevens moeten expliciet worden teruggegeven of gedeeld.
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)Resultaten terugkrijgen
Omdat geheugen niet wordt gedeeld, geef je resultaten terug via Pool.map, uitvoerders of wachtrijen, in plaats van globale variabelen te wijzigen.
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 voor afzonderlijke aanroepen
apply_async plant één aanroep in en geeft een resultaatverwijzing terug. Roep .get() aan om de waarde op te halen.
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())Vereiste voor serialisatie
Doelen en argumenten moeten serialiseerbaar zijn, zodat ze de procesgrens kunnen passeren. Functies op topniveau werken; lambda's en lokale functies meestal niet.
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]))Wanneer je processen gebruikt
Gebruik processen voor CPU-gebonden werk: wiskundige berekeningen, beeldverwerking en parseren. De overhead van het starten en serialiseren betekent dat processen beter geschikt zijn voor minder, zwaardere taken dan voor veel kleine taken.
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]))Korte controle
Toets je begrip van multiprocessing.
Samenvatting
Je hebt de basisbeginselen van multiprocessing geleerd:
- Processen omzeilen de GIL voor echte CPU-paralleliteit.
- Gebruik de
if __name__ == '__main__'-beveiliging. PoolenProcessPoolExecutorverdelen werk en verzamelen resultaten.- Geheugen wordt niet gedeeld; argumenten moeten serialiseerbaar zijn.
Volgende: gegevens veilig delen met wachtrijen en vergrendelingen.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 76
- Lessen
- 320
Veelgestelde vragen
Is de les “Basisprincipes van multiprocessing” gratis?
Ja — de volledige tekst van “Basisprincipes van multiprocessing” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.
Wat leer ik in “Basisprincipes van multiprocessing”?
Gebruik meerdere CPU-kernen Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Python Academy te beginnen?
Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Basisprincipes van multiprocessing”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Python Academy?
Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Threads en de GIL
- ThreadPoolExecutor
- Basisprincipes van multiprocessing
- Gegevens veilig delen