Wat is parallelisme in programmeren?

Parallelisme in programmeren is het gelijktijdig uitvoeren van meerdere taken of de schijn van gelijktijdige uitvoering, wat de prestaties en de responsiviteit van applicaties verhoogt.

Er worden verschillende vormen van parallelisme onderscheiden:

• Multiprocessing: Gebruikt meerdere onafhankelijke processen, elk met hun eigen adresruimte. Dit omzeilt de beperking van GIL (Global Interpreter Lock) in CPython en is geschikt voor CPU-intensieve taken.

  import multiprocessing
  import time
  
  def worker(num):
      """Een taak"""
      time.sleep(1)
      print(f'Werker {num} klaar')
  
  if __name__ == '__main__':
      processen = []
      for i in range(5):
          p = multiprocessing.Process(target=worker, args=(i,))
          processen.append(p)
          p.start()
  
      for p in processen:
          p.join()
      print("Alle werkers klaar")
  

• Multithreading: Gebruikt meerdere threads binnen één proces, die hetzelfde adresruimte delen. Vanwege GIL in CPython worden threads niet parallel uitgevoerd op verschillende cores voor CPU-bound taken, maar zijn ze effectief voor I/O-bound taken.

  import threading
  import time
  
  def worker(num):
      """Een taak"""
      time.sleep(1) # Simulatie van I/O-operatie
      print(f'Thread {num} klaar')
  
  threads = []
  for i in range(5):
      t = threading.Thread(target=worker, args=(i,))
      threads.append(t)
      t.start()
  
  for t in threads:
      t.join()
  print("Alle threads klaar")
  

• Asynchrone programmeren (Asyncio): Gebruikt één thread en een event loop om taken te beheren. Geschikt voor high-load I/O-bound applicaties en webservers. Blokkeert niet tijdens het wachten op I/O.

  import asyncio
  import time
  
  async def worker(num):
      """Een asynchrone taak"""
      await asyncio.sleep(1) # Asynchrone I/O-wachttijd
      print(f'Async worker {num} klaar')
  
  async def main():
      tasks = []
      for i in range(5):
          task = asyncio.create_task(worker(i))
          tasks.append(task)
      await asyncio.gather(*tasks)
      print("Alle async workers klaar")
  
  if __name__ == '__main__':
      asyncio.run(main())
  

De keuze van aanpak hangt af van de aard van de taak:

Aanpak	CPU-bound taken	I/O-bound taken	GIL	Geheugengebruik
Multiprocessing	Uitstekend	Goed	Omzeilt	Groot (eigen proces)
Multithreading	Slecht (door GIL)	Uitstekend	Blokkeert	Klein (gedeeld proces)
Asynchroon	Slecht	Uitstekend	Blokkeert niet	Klein (één thread)

Parallelisme vereist zorgvuldig beheer van synchronisatie en bronnen om racecondities en deadlocks te voorkomen.