Mis on paralleelsus programmeerimises?

Paralleelism programmimises tähendab mitme ülesande samaaegset või näiliselt samaaegset täitmist, mis võimaldab parandada rakenduste jõudlust ja reageerimisvõimet.

On mitu paralleelismi tüüpi:

• Mitmeprotsessorite kasutamine (Multiprocessing): Kasutab mitut sõltumatut protsessi, igaühel oma aadressiruumi. See ületab GIL-i (Global Interpreter Lock) piirangu CPythonis ja sobib CPU-intensiivsete ülesannete jaoks.

  import multiprocessing
  import time
  
  def worker(num):
      """Mõni töö"""
      time.sleep(1)
      print(f'Tööline {num} lõpetas')
  
  if __name__ == '__main__':
      protsessid = []
      for i in range(5):
          p = multiprocessing.Process(target=worker, args=(i,))
          protsessid.append(p)
          p.start()
  
      for p in protsessid:
          p.join()
      print("Kõik töömehed lõpetasid")
  

• Mitme-jooneline (Multithreading): Kasutab ühe protsessi sees mitut joont, mis jagavad ühise aadressiruumi. GIL-i tõttu CPythonis ei tööta jooned paralleelselt mitmel tuumal CPU-bound ülesannete puhul, kuid on tõhusad I/O-bound ülesannete jaoks.

  import threading
  import time
  
  def worker(num):
      """Mõni töö"""
      time.sleep(1) # I/O operatsiooni imitatsioon
      print(f'Joon {num} lõpetas')
  
  jooned = []
  for i in range(5):
      t = threading.Thread(target=worker, args=(i,))
      jooned.append(t)
      t.start()
  
  for t in jooned:
      t.join()
  print("Kõik jooned lõpetasid")
  

• Asünkroonne programmeerimine (Asyncio): Kasutab ühte joont ja sündmuste tsüklit (event loop) ülesannete haldamiseks. Sobib suure koormusega I/O-bound rakendustele ja veebiserveritele. Ei blokeeri täitmist oote ajal I/O jaoks.

  import asyncio
  import time
  
  async def worker(num):
      """Mõni asünkroonne töö"""
      await asyncio.sleep(1) # Asünkroonne ooteaeg I/O jaoks
      print(f'Async worker {num} lõpetas')
  
  async def main():
      ülesanded = []
      for i in range(5):
          ülesanne = asyncio.create_task(worker(i))
          ülesanded.append(ülesanne)
      await asyncio.gather(*ülesanded)
      print("Kõik asünkroonsed töötajad lõpetasid")
  
  if __name__ == '__main__':
      asyncio.run(main())
  

Valik sõltub ülesande iseloomust:

Lähenemine	CPU-põhised ülesanded	I/O-põhised ülesanded	GIL	Mälu kasutus
Mitmeprotsessorite kasutamine	Suurepärane	Hea	Läbib	Suur (oma protsess)
Mitmejooneline (Multithreading)	Halb (GIL tõttu)	Suurepärane	Blokeerib	Väike (ühe protsessi)
Asünkroonne	Halb	Suurepärane	Ei blokeeri	Väike (üks joon)

Paralleelism nõuab hoolikat sünkroniseerimise ja ressursside haldamist, et vältida võistlusolukordi (race conditions) ja deadlock'e (mõrvaolukordi).