Kako poboljšati svoj Python kod paralelnošću i paralelizmom

Ključni zahvati

• Konkurentnost i paralelizam temeljni su principi izvršavanja zadataka u računalstvu, a svaki od njih ima svoje različite karakteristike.
• Konkurentnost omogućuje učinkovito korištenje resursa i poboljšani odziv aplikacija, dok je paralelizam ključan za optimalnu izvedbu i skalabilnost.
• Python pruža opcije za rukovanje paralelnošću, kao što su niti i asinkrono programiranje s asyncio, kao i paralelizam pomoću višeprocesnog modula.

Konkurentnost i paralelizam dvije su tehnike koje vam omogućuju pokretanje nekoliko programa istovremeno. Python ima više opcija za istodobno i paralelno rukovanje zadacima, što može biti zbunjujuće.

Istražite alate i biblioteke dostupne za ispravnu implementaciju konkurentnosti i paralelizma u Pythonu i po čemu se razlikuju.

Razumijevanje istovremenosti i paralelizma

Konkurentnost i paralelizam odnose se na dva temeljna principa izvršavanja zadataka u računalstvu. Svaki ima svoje posebne karakteristike.

1. Konkurencija je sposobnost programa da upravlja s više zadataka u isto vrijeme, a da ih nužno ne izvrši u točno isto vrijeme. Vrti se oko ideje ispreplitanja zadataka, prebacivanja između njih na način koji se čini simultanim.
2. Paralelizam, s druge strane, uključuje istinsko paralelno izvršavanje više zadataka. Obično iskorištava više CPU jezgri ili procesora. Paralelizmom se postiže istinsko istovremeno izvršavanje, što vam omogućuje brže izvršavanje zadataka i dobro je prilagođen za računalno intenzivne operacije.

Važnost istovremenosti i paralelizma

Potreba za istovremenošću i paralelizmom u računalstvu ne može se precijeniti. Evo zašto su ove tehnike važne:

1. Korištenje resursa: Konkurentnost omogućuje učinkovito korištenje resursa sustava, osiguravajući da zadaci aktivno napreduju umjesto da dokono čekaju vanjske resurse.
2. Responzivnost: Konkurentnost može poboljšati odziv aplikacija, posebno u scenarijima koji uključuju korisnička sučelja ili web poslužitelje.
3. Izvođenje: Paralelizam je ključan za postizanje optimalne izvedbe, osobito u zadacima povezanim s procesorom kao što su složeni izračuni, obrada podataka i simulacije.
4. Skalabilnost: I konkurentnost i paralelizam ključni su za izgradnju skalabilnih sustava.
5. Zaštita budućnosti: Kako hardverski trendovi nastavljaju favorizirati višejezgrene procesore, mogućnost korištenja paralelizma postat će sve potrebnija.

Konkurentnost u Pythonu

Možete postići konkurentnost u Pythonu korištenjem niti i asinkronog programiranja s bibliotekom asyncio.

Threading u Pythonu

Threading je mehanizam paralelnosti Pythona koji vam omogućuje stvaranje i upravljanje zadacima unutar jednog procesa. Niti su prikladne za određene vrste zadataka, osobito one koji su I/O-vezani i mogu imati koristi od istovremenog izvršavanja.

Pythonova narezivanje navoja modul pruža sučelje visoke razine za stvaranje i upravljanje nitima. Iako GIL (Global Interpreter Lock) ograničava niti u smislu pravog paralelizma, one ipak mogu postići konkurentnost učinkovitim ispreplitanjem zadataka.

Kôd u nastavku prikazuje primjer implementacije paralelnosti pomoću niti. Koristi biblioteku zahtjeva Python za slanje HTTP zahtjeva, uobičajenog zadatka blokiranja I/O. Također koristi vremenski modul za izračun vremena izvršenja.

import requests
import time
import threading
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# function to request a URL
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")
# Execute without threads and measure execution time
start_time = time.time()
for url in urls:
 download_url(url)
end_time = time.time()
print(f"Sequential download took {end_time - start_time:.2f} seconds\n")
# Execute with threads, resetting the time to measure new execution time
start_time = time.time()
threads = []
for url in urls:
 thread = threading.Thread(target=download_url, args=(url,))
 thread.start()
 threads.append(thread)
# Wait for all threads to complete
for thread in threads:
 thread.join()
end_time = time.time()
print(f"Threaded download took {end_time - start_time:.2f} seconds")

Pokrećući ovaj program, trebali biste vidjeti koliko su zahtjevi u nitima brži od sekvencijalnih zahtjeva. Iako je razlika samo djelić sekunde, dobivate jasan osjećaj poboljšanja performansi kada koristite niti za I/O-vezane zadatke.

Asinkrono programiranje s Asynciom

asincio pruža petlju događaja koja upravlja asinkronim zadacima koji se nazivaju korutine. Korutine su funkcije koje možete pauzirati i nastaviti, što ih čini idealnim za I/O-vezane zadatke. Knjižnica je posebno korisna za scenarije u kojima zadaci uključuju čekanje vanjskih resursa, kao što su mrežni zahtjevi.

Prethodni primjer slanja zahtjeva možete modificirati da biste s njim radili asincio:

import asyncio
import aiohttp
import time
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# asynchronous function to request URL
asyncdefdownload_url(url):
asyncwith aiohttp.ClientSession() as session:
asyncwith session.get(url) as response:
 content = await response.text()
 print(f"Downloaded {url} - Status Code: {response.status}")
# Main asynchronous function
asyncdefmain():
# Create a list of tasks to download each URL concurrently
 tasks = [download_url(url) for url in urls]
# Gather and execute the tasks concurrently
await asyncio.gather(*tasks)
start_time = time.time()
# Run the main asynchronous function
asyncio.run(main())
end_time = time.time()
print(f"Asyncio download took {end_time - start_time:.2f} seconds")

Pomoću koda možete istovremeno preuzimati web stranice koristeći asincio i iskoristiti prednosti asinkronih I/O operacija. Ovo može biti učinkovitije od niti za I/O-vezane zadatke.

Paralelizam u Pythonu

Paralelizam možete implementirati pomoću Pythonova višeprocesiranje modul, što vam omogućuje da u potpunosti iskoristite višejezgrene procesore.

Višeprocesiranje u Pythonu

Pythonova višeprocesiranje modul pruža način za postizanje paralelizma stvaranjem zasebnih procesa, svaki sa svojim Python tumačem i memorijskim prostorom. Ovo učinkovito zaobilazi Global Interpreter Lock (GIL), što ga čini prikladnim za CPU zadatke.

import requests
import multiprocessing
import time
urls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
# function to request a URL
defdownload_url(url):
 response = requests.get(url)
 print(f"Downloaded {url} - Status Code: {response.status_code}")
defmain():
# Create a multiprocessing pool with a specified number of processes
 num_processes = len(urls)
 pool = multiprocessing.Pool(processes=num_processes)
 start_time = time.time()
 pool.map(download_url, urls)
 end_time = time.time()
# Close the pool and wait for all processes to finish
 pool.close()
 pool.join()
 print(f"Multiprocessing download took {end_time-start_time:.2f} seconds")
main()

U ovom primjeru, višeprocesiranje pokreće više procesa, omogućujući preuzimanje_url funkcija koja radi paralelno.

Kada koristiti istovremenost ili paralelizam

Izbor između istovremenosti i paralelizma ovisi o prirodi vaših zadataka i raspoloživim hardverskim resursima.

Možete koristiti istovremenost kada se bavite I/O-vezanim zadacima, kao što je čitanje i pisanje u datoteke ili slanje mrežnih zahtjeva i kada su memorijska ograničenja važna.

Koristite višeprocesiranje kada imate zadatke vezane za CPU koji mogu imati koristi od pravog paralelizma i kada imate robusnu izolaciju između zadataka, gdje neuspjeh jednog zadatka ne bi trebao utjecati na druge.

Iskoristite prednost istovremenosti i paralelizma

Paralelizam i istovremenost učinkoviti su načini poboljšanja odziva i izvedbe vašeg Python koda. Važno je razumjeti razlike između ovih koncepata i odabrati najučinkovitiju strategiju.

Python nudi alate i module koji su vam potrebni da svoj kod učinite učinkovitijim kroz konkurentnost ili paralelizam, neovisno o tome radite li s procesima vezanim za CPU ili I/O.