Brug disse teknikker til at køre kode samtidigt og give en jævnere brugeroplevelse.
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.
- Samtidighed er et programs evne til at håndtere flere opgaver på samme tid uden nødvendigvis at udføre dem på nøjagtig samme tid. Det drejer sig om ideen om at sammenflette opgaver, skifte mellem dem på en måde, der ser ud samtidig.
- Parallelisme, på den anden side involverer at udføre flere opgaver reelt parallelt. Det udnytter typisk flere CPU-kerner eller processorer. Parallelisme opnår ægte samtidig udførelse, lader dig udføre opgaver hurtigere og er velegnet til beregningsintensive operationer.
Betydningen af samtidighed og parallelisme
Behovet for samtidighed og parallelitet i databehandling kan ikke overvurderes. Her er hvorfor disse teknikker betyder noget:
- Ressourceudnyttelse: Samtidighed giver mulighed for effektiv udnyttelse af systemressourcer, hvilket sikrer, at opgaverne aktivt gør fremskridt i stedet for at vente på eksterne ressourcer.
- Lydhørhed: Samtidighed kan forbedre applikationernes reaktionsevne, især i scenarier, der involverer brugergrænseflader eller webservere.
- Ydeevne: Parallelisme er afgørende for at opnå optimal ydeevne, især i CPU-bundne opgaver som komplekse beregninger, databehandling og simuleringer.
- Skalerbarhed: Både samtidighed og parallelitet er afgørende for at bygge skalerbare systemer.
- Fremtidssikring: Da hardwaretrends fortsætter med at favorisere multicore-processorer, bliver evnen til at udnytte parallelitet i stigende grad nødvendig.
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.
Python's trådning modul 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å tidsmodul til at beregne udførelsestid.
import requests
import time
import threadingurls = [
'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")
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 anmodningsudsendelseseksempel til at arbejde med asyncio:
import asyncio
import aiohttp
import timeurls = [
'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")
Ved at bruge koden kan du downloade websider samtidig vha 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 Python's multibearbejdning modul, som giver dig mulighed for at drage fuld fordel af multicore-processorer.
Multiprocessing i Python
Python's multibearbejdning 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',
]# 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()
I dette eksempel, multibearbejdning afføder flere processer, hvilket tillader download_url funktion til 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 skal håndtere I/O-bundne opgaver, som f.eks 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.
