Mi a párhuzamosság a programozásban?

A párhuzamosság a programozásban több feladat egyidejű vagy látszólagos egyidejű végrehajtását jelenti, ami növeli az alkalmazások teljesítményét és reakcióképességét.

Többféle párhuzamosság létezik:

• Többprocesszorosság (Multiprocessing): Több független folyamatot használ, mindegyik saját címtérrel. Ez megkerüli a GIL (Global Interpreter Lock) korlátozását a CPythonban, és CPU-intenzív feladatokra alkalmas.

  import multiprocessing
  import time
  
  def worker(num):
      """Valamilyen munka"""
      time.sleep(1)
      print(f'Worker {num} befejezte')
  
  if __name__ == '__main__':
      processes = []
      for i in range(5):
          p = multiprocessing.Process(target=worker, args=(i,))
          processes.append(p)
          p.start()
  
      for p in processes:
          p.join()
      print("Minden munkás befejeződött")
  

• Többszálúság (Multithreading): Egy folyamaton belül több szálat használ, amelyek megosztják a közös címtérét. A GIL miatt CPythonban a szálak nem futnak párhuzamosan több magon CPU-bound feladatoknál, de hatékonyak I/O-bound feladatoknál.

  import threading
  import time
  
  def worker(num):
      """Valamilyen munka"""
      time.sleep(1) # I/O művelet szimulálása
      print(f'Szál {num} befejezte')
  
  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("Minden szál befejeződött")
  

• Aszinkron programozás (Asyncio): Egy szálat és eseményhurkot (event loop) használ a feladatok kezelésére. Alkalmas nagy terhelésű I/O-bound alkalmazásokhoz és webkiszolgálókhoz. Nem blokkolja a végrehajtást I/O várakozás közben.

  import asyncio
  import time
  
  async def worker(num):
      """Valamilyen aszinkron munka"""
      await asyncio.sleep(1) # Aszinkron I/O várakozás
      print(f'Async worker {num} befejezte')
  
  async def main():
      tasks = []
      for i in range(5):
          task = asyncio.create_task(worker(i))
          tasks.append(task)
      await asyncio.gather(*tasks)
      print("Minden async munkás befejeződött")
  
  if __name__ == '__main__':
      asyncio.run(main())
  

A megközelítés kiválasztása a feladat jellemzőitől függ:

Megközelítés	CPU-kötött feladatok	I/O-kötött feladatok	GIL	Memóriahasználat
Többprocesszorosság	Kiváló	Jó	Kikerüli	Nagy (saját folyamat)
Többszálúság	Rossz (a GIL miatt)	Kiváló	Blokkolja	Kisebb (közös folyamat)
Aszinkron	Rossz	Kiváló	Nem blokkol	Kisebb (egy szál)

A párhuzamosság óvatos szinkronizációs és erőforrás-kezelést igényel, hogy elkerüljük a versenyhelyzeteket (race conditions) és a holtpontokat (deadlocks).