Sådan forbedrer du din Python-kode med samtidighed og parallelisme

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.

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 involverer på den anden side at udføre flere opgaver reelt parallelt. Det drager typisk fordel af flere CPU-kerner eller processorer. Parallelisme opnår ægte samtidig udførelse, lader dig udføre opgaver hurtigere og er velegnet til beregningsintensive operationer.

Hvad du ikke vidste om estimering af projektomkostninger

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 passivt 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: Efterhånden som hardwaretrends fortsætter med at favorisere multicore-processorer, vil evnen til at udnytte parallelitet blive mere og mere 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.

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.

Sådan rettes Flyt Excel-kolonnefejl

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.

Sådan rejser du i tid i "Animal Crossing: New Horizons"

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.