Indholdsfortegnelse
Nøgle takeaways
- Samtidighed og parallelitet er grundlæggende principper for opgaveudførelse inden for databehandling, med hver deres særskilte karakteristika.
- Samtidighed giver mulighed for effektiv ressourceudnyttelse og forbedret reaktionsevne af applikationer, mens parallelitet er afgørende for optimal ydeevne og skalerbarhed.
- Python giver muligheder for at håndtere samtidighed, såsom threading og asynkron programmering med asyncio, samt parallelitet ved brug af multiprocessing-modulet.
Samtidighed og parallelisme er to teknikker, der lader dig køre flere programmer samtidigt. Python har flere muligheder for at håndtere opgaver samtidigt og parallelt, hvilket kan være forvirrende.
Udforsk de tilgængelige værktøjer og biblioteker til korrekt implementering af samtidighed og parallelitet i Python, og hvordan de adskiller sig.
Forståelse af samtidighed og parallelisme
Samtidighed og parallelisme refererer til to grundlæggende principper for opgaveudførelse inden for databehandling. Hver har sine særskilte egenskaber.
Betydningen af samtidighed og parallelisme
Behovet for samtidighed og parallelitet i databehandling kan ikke overvurderes. Her er hvorfor disse teknikker betyder noget:
Samtidighed i Python
Du kan opnå samtidighed i Python ved at bruge threading og asynkron programmering med asyncio-biblioteket.
Trådning i Python
Threading er en Python samtidighedsmekanisme, der giver dig mulighed for at oprette og administrere opgaver inden for en enkelt proces. Tråde er velegnede til visse typer opgaver, især dem, der er I/O-bundne og kan drage fordel af samtidig udførelse.
Pythons trådningsmodul giver en grænseflade på højt niveau til oprettelse og styring af tråde. Mens GIL (Global Interpreter Lock) begrænser tråde i form af ægte parallelitet, kan de stadig opnå samtidighed ved at sammenflette opgaver effektivt.
Koden nedenfor viser et eksempel på implementering af samtidighed ved hjælp af tråde. Det bruger Python-anmodningsbiblioteket til at sende en HTTP-anmodning, en almindelig I/O-blokeringsopgave. Den bruger også tidsmodulet til at beregne udførelsestid.
import requests
import time
import threadingurls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
def download_url(url):
response = requests.get(url)
print(f"Downloaded {url} - Status Code: {response.status_code}")
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")
start_time = time.time()
threads = []for url in urls:
thread = threading.Thread(target=download_url, args=(url,))
thread.start()
threads.append(thread)
for thread in threads:
thread.join()end_time = time.time()
print(f"Threaded download took {end_time - start_time:.2f} seconds")
Når du kører dette program, bør du se, hvor meget hurtigere de trådede anmodninger er end de sekventielle anmodninger. Selvom forskellen kun er en brøkdel af et sekund, får du en klar fornemmelse af præstationsforbedringen, når du bruger tråde til I/O-bundne opgaver.
Asynkron programmering med Asyncio
asyncio leverer en hændelsesløkke, der administrerer asynkrone opgaver kaldet coroutines. Coroutines er funktioner, som du kan sætte på pause og genoptage, hvilket gør dem ideelle til I/O-bundne opgaver. Biblioteket er især nyttigt til scenarier, hvor opgaver involverer at vente på eksterne ressourcer, såsom netværksanmodninger.
Du kan ændre det tidligere anmodnings-afsendelseseksempel til at arbejde med asyncio:
import asyncio
import aiohttp
import timeurls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
async def download_url(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
content = await response.text()
print(f"Downloaded {url} - Status Code: {response.status}")
async def main():
tasks = [download_url(url) for url in urls]
await asyncio.gather(*tasks)start_time = time.time()
asyncio.run(main())end_time = time.time()
print(f"Asyncio download took {end_time - start_time:.2f} seconds")
Ved at bruge koden kan du downloade websider samtidigt ved at bruge asyncio og drage fordel af asynkrone I/O-operationer. Dette kan være mere effektivt end threading til I/O-bundne opgaver.
Parallelisme i Python
Du kan implementere parallelitet vha Pythons multiprocessing-modulsom giver dig mulighed for at drage fuld fordel af multicore-processorer.
Multiprocessing i Python
Pythons multiprocessing-modul giver en måde at opnå parallelitet ved at skabe separate processer, hver med sin egen Python-fortolker og hukommelsesplads. Dette omgår effektivt Global Interpreter Lock (GIL), hvilket gør den velegnet til CPU-bundne opgaver.
import requests
import multiprocessing
import timeurls = [
'https://www.google.com',
'https://www.wikipedia.org',
'https://www.makeuseof.com',
]
def download_url(url):
response = requests.get(url)
print(f"Downloaded {url} - Status Code: {response.status_code}")def main():
num_processes = len(urls)
pool = multiprocessing.Pool(processes=num_processes)start_time = time.time()
pool.map(download_url, urls)
end_time = time.time()
pool.close()
pool.join()print(f"Multiprocessing download took {end_time-start_time:.2f} seconds")
main()
I dette eksempel afføder multiprocessing flere processer, hvilket tillader download_url-funktionen at køre parallelt.
Hvornår skal man bruge samtidighed eller parallelisme
Valget mellem samtidighed og parallelitet afhænger af arten af dine opgaver og de tilgængelige hardwareressourcer.
Du kan bruge samtidighed, når du håndterer I/O-bundne opgaver, såsom at læse og skrive til filer eller lave netværksanmodninger, og når hukommelsesbegrænsninger er et problem.
Brug multiprocessing, når du har CPU-bundne opgaver, der kan drage fordel af ægte parallelitet, og når du har robust isolation mellem opgaver, hvor en opgaves fejl ikke bør påvirke andre.
Udnyt samtidighed og parallelisme
Parallelisme og samtidighed er effektive måder til at forbedre responsen og ydeevnen af din Python-kode. Det er vigtigt at forstå forskellene mellem disse koncepter og vælge den mest effektive strategi.
Python tilbyder de værktøjer og moduler, du skal bruge for at gøre din kode mere effektiv gennem samtidighed eller parallelitet, uanset om du arbejder med CPU-bundne eller I/O-bundne processer.