Kas ir paralēlisms programmēšanā?

Paralēlisms programmēšanā ir vairākas uzdevumu izpilde vienlaikus vai šķietami vienlaikus, kas ļauj uzlabot lietojumprogrammu veiktspēju un reakcijas ātrumu.

Ir vairāki paralēlismu veidi:

• Daudzprocesoru (Multiprocessing): Izmanto vairākus neatkarīgus procesus, katru ar savu adreses telpu. Tas pārvar GIL (Global Interpreter Lock) ierobežojumu CPython un ir piemērots CPU intensīvām uzdevumiem.

  import multiprocessing
  import time
  
  def worker(num):
      """Kāda darba"""
      time.sleep(1)
      print(f'Darbinieks {num} pabeidza')
  
  if __name__ == '__main__':
      procesi = []
      for i in range(5):
          p = multiprocessing.Process(target=worker, args=(i,))
          procesi.append(p)
          p.start()
  
      for p in procesi:
          p.join()
      print("Visi darbinieki pabeidza")
  

• Daudzšlīnu (Multithreading): Izmanto vairākus pavedienus vienā procesā, kas dalās kopīgā adreses telpā. Dēļ GIL CPython, pavedieni netiek izpildīti paralēli vairākos kodola darbiniekiem CPU-bound uzdevumiem, bet ir efektīvi I/O-bound uzdevumiem.

  import threading
  import time
  
  def worker(num):
      """Kāda darba"""
      time.sleep(1) # I/O operācijas imitācija
      print(f'Vītnes {num} pabeidza')
  
  vītnes = []
  for i in range(5):
      t = threading.Thread(target=worker, args=(i,))
      vītnes.append(t)
      t.start()
  
  for t in vītnes:
      t.join()
  print("Visas vītnes pabeidza")
  

• Asinhronā programmēšana (Asyncio): Izmanto vienu pavedienu un notikumu cilpu (event loop) uzdevumu pārvaldībai. Piemērots augstas slodzes I/O-bound lietojumprogrammām un tīmekļa serveriem. Neaizkavē izpildi gaidot I/O.

  import asyncio
  import time
  
  async def worker(num):
      """Kāda asinhroniska darba"""
      await asyncio.sleep(1) # Asinhrona gaidīšana I/O
      print(f'Async worker {num} pabeidza')
  
  async def main():
      uzdevumi = []
      for i in range(5):
          uzdevums = asyncio.create_task(worker(i))
          uzdevumi.append(uzdevums)
      await asyncio.gather(*uzdevumi)
      print("Visi asinhroniski darbinieki pabeidza")
  
  if __name__ == '__main__':
      asyncio.run(main())
  

Izvēle ir atkarīga no uzdevuma rakstura:

Pieeja	CPU-uzņēmīgas uzdevumi	I/O-uzņēmīgas uzdevumi	GIL	Atmiņas izmantošana
Daudzprocesoru	Izcili	Labi	Pārliecinās	Liels (sava procesa)
Daudzšlīnu	Slikti (dēļ GIL)	Izcili	Bloķē	Mazs (kopīgs process)
Asinhroni	Slikti	Izcili	Neaizkavē	Mazs (viens pavedienis)

Paralēlisms prasa uzmanīgu sinhronizācijas un resursu pārvaldību, lai izvairītos no sacensības stāvokļiem (race conditions) un mirstošajām vietām (deadlocks).