Asyncio, threads en processen maken het mogelijk om meerdere taken tegelijk uit te voeren, maar verschillen sterk in uitvoering, foutgedrag en beheer van gedeelde gegevens. Je leest hoe je de juiste aanpak kiest voor I/O-gebonden en processorintensieve code, en welke gevolgen die keuze heeft voor de architectuur van een Python-applicatie.
Concurrency en parallelisme in Python zijn niet hetzelfde
Concurrency gaat erom dat je code meerdere taken beheert die overlappen of elkaar afwisselen. Parallelisme betekent echt tegelijk uitvoeren van taken. Dat verschil maakt uit voor keuzes in Python. Bij asyncio gebeurt afwisselen meestal op maar één thread: die 'springt' tussen coroutines. Threads maken het mogelijk om tijdens I/O te wachten, maar door de Global Interpreter Lock (GIL) voert één enkele thread tegelijk Python-bytecode uit. Wil je code echt op verschillende processorkernen laten draaien? Dat kan alleen met aparte processen.
Kijk daarom eerst waar je code vooral op wacht. Blijft de CPU weinig belast maar duurt het lang, dan zijn calls naar netwerk of disk vermoedelijk de bottleneck. Loopt de processor steeds vol? Dan helpt concurrency binnen dezelfde thread niet verder bij het versnellen van je werk.
Je zult moeten meten. Wat doet je huidige app qua wachttijd, CPU-belasting, geheugen en aantal syncverzoeken? Iemand met veel I/O-taken maar weinig CPU kan bijvoorbeeld traag reageren door per verzoek te wachten. Een CPU-volle app snakt daarentegen naar verdeling over meerdere processen. Zonder zulke analyse kan het overschakelen naar bijvoorbeeld async, threads of multiprocessing vooral extra complexiteit opleveren zonder nuttig effect. Voor hulp bij de bouw of doorontwikkeling kun je een freelance developer inschakelen.
Deze GIL-beschrijving geldt voor standaard-CPython-builds; sinds Python 3.13 zijn ook free-threaded builds beschikbaar waarin de GIL kan worden uitgeschakeld.
Asyncio voor veel gelijktijdige I/O-taken
Met asyncio beheer je heel wat I/O-taken tegelijk, zolang de libraries asynchroon werken. Een coroutine geeft bij elke await de controle aan de eventloop terug. Zolang een HTTP-verzoek ergens onderweg is, laat de eventloop een andere coroutine iets doen. Zo kun je op één enkele thread honderden open verbindingen tegelijk draaien, zonder stapels threads aan te maken. De asyncio-documentatie beschrijft hoe coroutines en taken samenwerken.
Dit werkt alleen als elke schakel in de keten asynchroon is. Roep je in een coroutine toch een gewone, blokkerende functie aan? Dan stopt de hele eventloop tot die functie klaar is. Alles wat niet asynchroon werkt, van netwerkclients tot zware bestandsbewerkingen, veroorzaakt stilstand. Gebruik waar dat nodig is asynchrone packages of run blokkerende code in een thread- of processpool.
Asyncio laat je zelf aan de touwtjes trekken. Te snel taken aanmaken zonder limiet? Dan groeit het aantal wachtende jobs tot alles vastloopt. Grenstaken, bijvoorbeeld met een semaphore of begrensde queue. Vergeet niet om time-outs te hanteren, of taken af te breken zodra niemand meer op ze wacht. Asyncio past goed bij servers of clients met veel netwerkverkeer, zolang de bottleneck buiten de eventloop blijft.
Python-threads voor blokkerende I/O en bestaande bibliotheken
Threads komen vooral van pas als je I/O-taken hebt waarbij gebruikte modules niet asynchroon te benaderen zijn. Eén thread kan blijven wachten tot een response binnenkomt, terwijl een andere thread intussen al verdergaat. Deze aanpak is soms de snelste manier om bestaande sync-code toch parallel te draaien, zonder alles te herschrijven voor coroutines.
Voor rekenintensieve code win je in Python minder: door de GIL draait steeds maar één thread tegelijk op Python-niveau. Sommige native libraries laten de GIL wel los tijdens eigen rekentaken of I/O, dan zie je alsnog performance-winst via threads. Of dat gebeurt hangt af van de gebruikte module; je moet meten in een situatie die op productie lijkt.
Let ook op het delen van data. Threads delen hun memory space, dus kun je gemakkelijk gegevens uitwisselen, maar dat werkt fouten in de hand. Gebruik thread-safe queues, locks van threading of immutable objects, maar vertrouw niet op 'het zal wel goedgaan'. Houd het aantal threads binnen de perken. Te veel threads vreten geheugen en kunnen externe services in de knel brengen. Je kiest threads vooral als compatibiliteit en eenvoudige integratie belangrijker zijn dan maximale regie over uitvoering.
Multiprocessing voor processorintensief werk
Multiprocessing pakt elke rekentaak met een losse OS-proces aan. Ze krijgen een aparte eigen interpreter, strak gescheiden geheugen en kunnen echt tegelijk op meerdere cores draaien. Geschikt bij rekenwerk als data-analyse op grote bestanden, parallelliseren van beeldbewerkingen of het genereren van veel losse resultaten. Een process pool zorgt dat je niet zelf losse processen per taak hoeft te starten. De officiële documentatie voor multiprocessing legt onder meer process pools uit.
Maar: objecten moeten bij multiprocessing tussen processen heen en weer, met serialisatie en kopieerkosten. Als het om grote datasets of complexe structs gaat, kan overdracht snel meer tijd en geheugen kosten dan de eigenlijke berekening. Process pools geven het beste resultaat als de taken niet al te klein zijn en zo onafhankelijk mogelijk werken. Deel dus geen grote objectgrafen, maar verwijs liever naar bestandsnamen, ids of gedeelde storage als dat kan.
Let ook op platformverschillen bij het starten van processen; onder Windows kan dat bijvoorbeeld anders werken dan op Linux. Code die onverwacht bij het importeren meteen processen aanmaakt, kan problemen opleveren. Beheer het pool-leven en zorg dat fouten en afsluiten netjes verlopen. Process pools nemen ook meer geheugen dan (meestal lichtere) threads. Multiprocessing is handig als metingen uitwijzen dat de CPU het knelpunt is en je taken makkelijk los over processen kunt verdelen.
Gedeelde toestand beheersen met locks, queues en processen
Hoe threads, processen of coroutines gegevens delen laat een grote impact op de stabiliteit van je code achter. Threads zitten standaard samen in hetzelfde geheugen. Tegelijk iets wijzigen in bijvoorbeeld een dict of list? Kans dat resultaten verloren gaan of data in een ongeldige toestand eindigt. De GIL stopt zulke fouten soms niet, want bewerkingen bestaan vaak uit meerdere stappen die een andere thread kunnen onderbreken.
Locks houden delen van je code even 'onder elkaar', maar te lang of slordig locken zorgt juist voor vastlopers of performanceverlies. Wachtende threads houden soms resources bezet die weer nodig zijn voor anderen, wat kan vastlopen. Gebruik, waar handig, een thread-safe queue om berichten of opdrachten tussen threads te verplaatsen. Dat geeft overzicht en voorkomt dat twee writers tegelijk in dezelfde structuur zitten te rommelen.
Processen geven standaard niets door via hun gewone geheugen. Met queues, pipes, gedeeld geheugen of opslag bouw je expliciete lijntjes. Dat maakt gedrag voorspelbaarder, maar je krijgt er serialisatie en synchronisatie bij. Bij asyncio draait alles meestal in dezelfde thread, dus 'gewoon' wijzigen is eenvoudiger, zolang je geen await doet middenin een wijziging. Houd altijd de eigenaar van data duidelijk: niet alleen het snelste pad uit de eerste meting, maar een pad waar invarianten overeind blijven.
Foutafhandeling, annulering en levenscyclus van taken
Bij concurrency komen fouten vaker ergens anders terecht dan verwacht. In synchrone code zie je een exception vaak direct in de call stack. Als taken tegelijk lopen, kan een taak mislukken zonder dat de aanroeper daar meteen iets van merkt. Zorg dus actief voor een strategie: waar vang je exceptions, hoe haalt iets z’n resultaat op, wat doe je als andere taken afhankelijk zijn van een mislukte?
Met asyncio hoort annuleren gewoon bij het leven van een taak. Een time-out of een verbroken client annuleert een coroutine. Schrijf expliciet wat er dan moet gebeuren, bijvoorbeeld het sluiten van een verbinding. Gebruik een task group voor samenhangende taken, zodat je bij één fout alles kunt opruimen. Laat geen achtergrondtaken doordraaien als hun werk zinloos is geworden door een afgehandeld verzoek.
Voor threads en processen komen fouten meestal pas boven water als de hoofdthread een future-resultaat opvraagt. Doe je dat nergens, blijven uitzonderingen onzichtbaar. Je kunt niet altijd middenin een thread veilig stoppen: gebruik signalen als flags of time-outs. Processen kun je killen, maar dat kan voor half afgemaakte bestanden of niet afgesloten resources zorgen. Leg voor elke soort taak vast wat annuleerbaar, herstartbaar en herstelbaar is. Zonder goed beleid worden fouten onopgemerkt of blijken resources na een fout niet opgeruimd.
Een applicatie met meerdere concurrency-modellen opbouwen
Je kiest niet voor één concurrency-model in een app. Het komt voor dat een webserver async requests verwerkt, een threadpool gebruikt voor ouderwetse I/O en een process pool inschakelt voor zware rekenklussen. Dit blijft alleen beheersbaar als je de snijvlakken van die modellen scherp houdt. Bepaal welk onderdeel welke taken start, stopt en bewaakt.
Zorg dat lagen geen modellen stilletjes met elkaar vermengen. Roep je een eventloop aan in code waar al één draait? Dat geeft snel problemen. Of draait een coroutine een blokkerende functie? Dan ligt de loop stil. Gebruik adapters met heldere contracten, waar, wanneer en op welke manier je code afhandelt, annuleert of faalt. Houd overdracht tussen concurrency-modellen klein en overzichtelijk.
Slimme architectuur scheidt coördinatie (de routering van werk) van de daadwerkelijke uitvoering. Dus: de coördinator screent een aanvraag en stuurt het werk naar een pool, zonder details van HTTP afhandeling of process management bij elkaar te gooien. Zo lekken patronen van threading, eventloops of processpools niet je hele codebase in. Vergeet ook niet: logcontext, traces en signalen voor shutdown moeten de grenzen tussen modellen oversteken. Anders blijft bij storingen niet alleen onduidelijk waar de oorzaak zit, maar kunnen gestopte delen resources achterlaten. Dit speelt ook bij automatisering met maatwerk. Lees ook over logging en foutafhandeling bij automatiseringen.
Backpressure en limieten voor gelijktijdig werk
Honderden taken tegelijk betekent niet automatisch meer verwerkt werk. Als je te veel werk aanneemt, groeien je queues, loopt geheugen vol en overvraag je externe APIs. Dit geldt bij threads, processen en async, alleen de bijkomende kosten verschillen. Zonder grenzen zie je vaak pas bij productie waartoe onbeperkte instroom leidt.
Backpressure voorkomt doorslaan. Beperk queues, stel semaphores of verbindingslimieten in en kies wat er gebeurt bij overschrijding: een verbinding weigeren, een producer laten wachten, of werk op disk zetten. De beste optie hangt af van de aard van het werk: is het een urgent request of een batch-job die in een queue kan wachten?
Zet limieten afgestemd op gebruikte resources en koppelingen. Stel: honderd threads die ieder een database connectie vragen terwijl er maar twintig connections mogen zijn; dat gaat mis. Of te veel processen vullen het geheugen vol. Onbegrensde coroutines kunnen alle filehandles of sockets in beslag nemen. Houd niet alleen de uitvoeringstijd bij, maar ook wachtrijlengte, een stijgende wachtrij wijst meestal op een knelpunt waar meer concurrency geen uitkomst biedt. Begrenzen leidt niet tot magisch meer performance, maar maakt bottlenecks wél sneller zichtbaar en houdt systemen leefbaar. Ook bij n8n-workflows helpen grenzen om werk beheersbaar te houden.
Concurrency testen en problemen in productie herkennen
Concurrency-problemen zijn vaak timing-gevoelig, en duren soms maanden voor ze zich voordoen. Een enkele succesvolle test betekent dus weinig als het om safe delen van gegevens of shutdown gaat. Test actief scenario’s waarin meerdere taken tegelijk dezelfde data willen wijzigen, services traag hun werk doen, een time-out optreedt of een worker ineens stukgaat. Kijk niet alleen naar einduitkomsten: zijn na tests alle sockets, processen, threads netjes afgesloten?
Meet niet met een standaard workload uit de handleiding, maar met echte praktijkdata en aantallen. Let op doorvoer én latency, kijk naar outliers want gemiddelden verbergen pieken. Monitor CPU, geheugen, poolgrootte, wachtrijen en de staat van de eventloop, en vergelijk gelijke workloads eerlijk. Bij multiprocessing kun je winnen in rekenkracht, maar soms verliezen door overdrachtskosten, dat zie je pas door alles samen te meten.
Bij asyncio geeft eventloopvertraging je een signaal van blokkerende code of langlopende taken. Bij threads zijn dode workers, lockwachttijd of pool-uitputting een belangrijk teken. Processes? Let op geheugengebruik per worker en de totale ophaaltijd van de resultaten. Leg altijd taak-id’s en contextgegevens in je log, zodat je een fout terugvindt bij het horende verzoek of proces. Zorg voor gecontroleerde shutdown; geen nieuwe instroom, bestaand werk netjes afronden, alle resources sluiten. Zo zie je of je gekozen aanpak niet alleen in theorie, maar ook in zware praktijk bestaat blijft houden.
Veelgestelde vragen
Hoe bepaal ik het juiste aantal workers voor een Python-pool?
Gebruik metingen onder praktijkbelasting, geen standaardgetal werkt altijd. Begin klein, verhoog stapsgewijs en meet doorvoer, wachttijd, memory en de druk op externe services.
- Voor I/O-werk kun je meer workers nemen dan er cpu-cores zijn, maar begrens door aantal connecties of API-limieten.
- Voor CPU-werk is het aantal fysieke cores een goed beginpunt.
- Test ook pieken: extra workers moeten echt een snellere app opleveren.
Hoe test ik race conditions in Python-threads?
Doorloop race conditions door shared state tegelijk van meerdere kanten te wijzigen en te checken of data klopt. Eén keer slagen zegt weinig, want race conditions zijn grillig en treden niet altijd op.
- Start veel gelijktijdige taken op identieke data en controleer de uitkomst op integriteit.
- Gebruik tools als barriers of events om gewenste situaties af te dwingen waar timing cruciaal is.
- Voer stress- en herhaaltests uit, inclusief checks op fouten en time-outs.
Blijf dit combineren met ontwerp-afspraken over eigenaarschap: testen vangen lang niet elke bug af.
Hoe test ik asyncio-code zonder een echte API of database?
Vervang een echte client door een asynchrone 'testdouble'. Die levert dummy-data, gooit fouten of wacht zoals een externe dienst zou doen.
- Controleer dat je coroutines klant-code awaiten en bij fouten goed reageren.
- Test afbreken tijdens wachten, annuleer een coroutine wanneer je bijvoorbeeld tijd overschrijdt.
- Voor integratie: gebruik een lokale testserver of tijdelijke database, maar hou die tests beperkt.
Zo hou je het meeste snel en voorspelbaar, terwijl je toch weet dat écht integreren soepel kan verlopen.
Hoe gebruik ik ProcessPoolExecutor veilig op Windows?
Plaats proces-aanmaak altijd achter een main-guard en definieer werkfuncties op moduleniveau. Windows start processen door de module opnieuw te importeren; als je code meteen pools maakt bij import, ontstaan steeds meer processen.
- Gebruik
if __name__ == "__main__":als startpunt voor pools of applicatie. - Geef alleen serialiseerbare argumenten mee naar workers.
- Sluit pools expliciet, en test het gedrag precies in de beoogde deployment.
Hoe voorkom ik te veel Python-processen bij Gunicorn en een procespool?
Let op: het totaal aantal processen wordt het aantal webworkers maal het aantal poolworkers. Wenn elke webworker een eigen pool heeft, kan het echte aantal processen flink hoger uitpakken dan je dacht.
- Reken met het volledige totaal aan processen, niet alleen per afzonderlijk app-proces.
- Houd niet alleen CPU, maar ook RAM en andere diensten in de gaten.
- Meet onder workload en pas daarna zowel pool- als webworker-aantallen aan.
Plaats pools daar waar de levenscyclus klopt; voorkom dat bij herstarten nieuwe pools blijven aanmaken of oude niet worden opgeruimd.
Foto: RUN 4 FFWPU