Gebruik deze technieken om tegelijkertijd code uit te voeren en een soepelere gebruikerservaring te bieden.
Belangrijkste leerpunten
- Gelijktijdigheid en parallellisme zijn fundamentele principes van taakuitvoering in computergebruik, waarbij elk zijn eigen specifieke kenmerken heeft.
- Gelijktijdigheid zorgt voor een efficiënt gebruik van hulpbronnen en een verbeterde responsiviteit van applicaties, terwijl parallellisme cruciaal is voor optimale prestaties en schaalbaarheid.
- Python biedt opties voor het omgaan met gelijktijdigheid, zoals threading en asynchrone programmering met asyncio, evenals parallellisme met behulp van de multiprocessing-module.
Gelijktijdigheid en parallellisme zijn twee technieken waarmee u meerdere programma's tegelijkertijd kunt uitvoeren. Python heeft meerdere opties voor het gelijktijdig en parallel afhandelen van taken, wat verwarrend kan zijn.
Ontdek de tools en bibliotheken die beschikbaar zijn voor het correct implementeren van gelijktijdigheid en parallellisme in Python, en hoe ze verschillen.
Gelijktijdigheid en parallellisme begrijpen
Gelijktijdigheid en parallellisme verwijzen naar twee fundamentele principes van taakuitvoering in computergebruik. Elk heeft zijn specifieke kenmerken.
- Gelijktijdigheid is het vermogen van een programma om meerdere taken tegelijkertijd te beheren zonder ze noodzakelijkerwijs op exact hetzelfde moment uit te voeren. Het draait om het idee om taken te verweven en ertussen te schakelen op een manier die gelijktijdig lijkt.
- ParallellismeAan de andere kant houdt het in dat meerdere taken daadwerkelijk parallel worden uitgevoerd. Meestal wordt er geprofiteerd van meerdere CPU-kernen of processors. Parallellisme zorgt voor echte gelijktijdige uitvoering, waardoor u taken sneller kunt uitvoeren, en is zeer geschikt voor rekenintensieve bewerkingen.
Het belang van gelijktijdigheid en parallellisme
De behoefte aan gelijktijdigheid en parallellisme in computers kan niet genoeg worden benadrukt. Dit is waarom deze technieken belangrijk zijn:
- Gebruik van hulpbronnen: Gelijktijdigheid maakt efficiënt gebruik van systeembronnen mogelijk en zorgt ervoor dat taken actief vooruitgang boeken in plaats van nutteloos te wachten op externe bronnen.
- Ontvankelijkheid: Gelijktijdigheid kan de responsiviteit van applicaties verbeteren, vooral in scenario's met gebruikersinterfaces of webservers.
- Prestatie: Parallellisme is cruciaal voor het bereiken van optimale prestaties, vooral bij CPU-gebonden taken zoals complexe berekeningen, gegevensverwerking en simulaties.
- Schaalbaarheid: Zowel gelijktijdigheid als parallellisme zijn essentieel voor het bouwen van schaalbare systemen.
- Toekomstbestendig: Nu hardwaretrends de voorkeur blijven geven aan multicore-processors, zal de mogelijkheid om parallellisme te benutten steeds noodzakelijker worden.
Gelijktijdigheid in Python
U kunt gelijktijdigheid in Python bereiken met behulp van threading en asynchrone programmering met de asyncio-bibliotheek.
Threaden in Python
Threading is een Python-concurrency-mechanisme waarmee u taken binnen één proces kunt maken en beheren. Threads zijn geschikt voor bepaalde soorten taken, vooral taken die I/O-gebonden zijn en baat kunnen hebben bij gelijktijdige uitvoering.
Python's draadsnijden module biedt een interface op hoog niveau voor het maken en beheren van threads. Hoewel de GIL (Global Interpreter Lock) threads beperkt in termen van echt parallellisme, kunnen ze nog steeds gelijktijdigheid bereiken door taken efficiënt te interleaven.
De onderstaande code toont een voorbeeldimplementatie van gelijktijdigheid met behulp van threads. Het gebruikt de Python-verzoekbibliotheek om een HTTP-verzoek te verzenden, een veel voorkomende I/O-blokkeertaak. Er wordt ook gebruik gemaakt van de tijdmodule om de uitvoeringstijd te berekenen.
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")
Als u dit programma uitvoert, zou u moeten zien hoeveel sneller de threadverzoeken zijn dan de sequentiële verzoeken. Hoewel het verschil slechts een fractie van een seconde bedraagt, krijgt u een duidelijk beeld van de prestatieverbetering bij het gebruik van threads voor I/O-gebonden taken.
Asynchrone programmering met Asyncio
asynchroon biedt een gebeurtenislus die asynchrone taken beheert, coroutines genaamd. Coroutines zijn functies die u kunt pauzeren en hervatten, waardoor ze ideaal zijn voor I/O-gebonden taken. De bibliotheek is met name handig voor scenario's waarbij bij taken moet worden gewacht op externe bronnen, zoals netwerkverzoeken.
U kunt het vorige voorbeeld voor het verzenden van verzoeken aanpassen om mee te werken asynchroon:
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")
Met behulp van de code kunt u webpagina's gelijktijdig downloaden met behulp van asynchroon en profiteer van asynchrone I/O-bewerkingen. Dit kan efficiënter zijn dan threading voor I/O-gebonden taken.
Parallellisme in Python
U kunt parallellisme implementeren met behulp van Python's multiverwerking module, waarmee u optimaal kunt profiteren van multicore-processors.
Multiverwerking in Python
Python's multiverwerking module biedt een manier om parallellisme te bereiken door afzonderlijke processen te creëren, elk met zijn eigen Python-interpreter en geheugenruimte. Dit omzeilt effectief het Global Interpreter Lock (GIL), waardoor het geschikt is voor CPU-gebonden taken.
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()
In dit voorbeeld multiverwerking brengt meerdere processen voort, waardoor de download_url functie parallel te laten draaien.
Wanneer moet u gelijktijdigheid of parallellisme gebruiken?
De keuze tussen gelijktijdigheid en parallellisme hangt af van de aard van uw taken en de beschikbare hardwarebronnen.
U kunt gelijktijdigheid gebruiken bij het omgaan met I/O-gebonden taken, zoals lezen en schrijven naar bestanden of het doen van netwerkverzoeken, en wanneer geheugenbeperkingen een probleem zijn.
Gebruik multiprocessing als u CPU-gebonden taken hebt die kunnen profiteren van echt parallellisme en als u over een robuuste isolatie tussen taken beschikt, waarbij het falen van de ene taak geen gevolgen voor andere taken zou moeten hebben.
Profiteer van gelijktijdigheid en parallellisme
Parallellisme en gelijktijdigheid zijn effectieve manieren om de responsiviteit en prestaties van uw Python-code te verbeteren. Het is belangrijk om de verschillen tussen deze concepten te begrijpen en de meest effectieve strategie te selecteren.
Python biedt de tools en modules die u nodig hebt om uw code effectiever te maken door middel van gelijktijdigheid of parallellisme, ongeacht of u werkt met CPU-gebonden of I/O-gebonden processen.
