Python-koodin parantaminen samanaikaisuuden ja rinnakkaisuuden avulla

Avaimet takeawayt

• Samanaikaisuus ja rinnakkaisuus ovat tehtävien suorittamisen perusperiaatteita laskennassa, ja jokaisella on omat erityispiirteensä.
• Samanaikaisuus mahdollistaa tehokkaan resurssien käytön ja sovellusten paremman reagoivuuden, kun taas rinnakkaisuus on ratkaisevan tärkeää optimaalisen suorituskyvyn ja skaalautuvuuden kannalta.
• Python tarjoaa vaihtoehtoja samanaikaisuuden käsittelyyn, kuten ketjuttaminen ja asynkroninen ohjelmointi asyncion kanssa, sekä rinnakkaisuus moniprosessointimoduulin avulla.

Samanaikaisuus ja rinnakkaisuus ovat kaksi tekniikkaa, joiden avulla voit ajaa useita ohjelmia samanaikaisesti. Pythonilla on useita vaihtoehtoja tehtävien käsittelyyn samanaikaisesti ja rinnakkain, mikä voi olla hämmentävää.

Tutustu käytettävissä oleviin työkaluihin ja kirjastoihin samanaikaisuuden ja rinnakkaisuuden asianmukaiseen toteuttamiseen Pythonissa ja niiden eroihin.

Samanaikaisuuden ja rinnakkaisuuden ymmärtäminen

Samanaikaisuus ja rinnakkaisuus viittaavat kahteen tehtävien suorittamisen perusperiaatteeseen laskennassa. Jokaisella on omat erityispiirteensä.

1. Samanaikaisuus on ohjelman kyky hallita useita tehtäviä samanaikaisesti ilman, että ne suorittavat välttämättä täsmälleen samaan aikaan. Se pyörii ajatuksen ympärillä tehtävien limittämisestä, vaihtamisesta niiden välillä tavalla, joka näyttää samanaikaiselta.
2. Rinnakkaisuustoisaalta edellyttää useiden tehtävien suorittamista aidosti rinnakkain. Se yleensä käyttää hyväkseen useita CPU-ytimiä tai prosessoreita. Rinnakkaisuus mahdollistaa todellisen samanaikaisen suorituksen, jolloin voit suorittaa tehtäviä nopeammin, ja se sopii hyvin laskennallisesti vaativiin toimintoihin.

Samanaikaisuuden ja rinnakkaisuuden merkitys

Samanaikaisuuden ja rinnakkaisuuden tarvetta laskennassa ei voi liioitella. Tästä syystä näillä tekniikoilla on merkitystä:

1. Resurssien käyttö: Samanaikaisuus mahdollistaa järjestelmän resurssien tehokkaan käytön varmistaen, että tehtävät edistyvät aktiivisesti sen sijaan, että joutuisivat odottamaan ulkoisia resursseja.
2. Reagointikykyä: Samanaikaisuus voi parantaa sovellusten reagointikykyä, erityisesti skenaarioissa, joihin liittyy käyttöliittymiä tai verkkopalvelimia.
3. Esitys: Rinnakkaisuus on ratkaisevan tärkeää optimaalisen suorituskyvyn saavuttamiseksi, erityisesti suorittimeen sidotuissa tehtävissä, kuten monimutkaisissa laskelmissa, tietojenkäsittelyssä ja simulaatioissa.
4. Skaalautuvuus: Sekä samanaikaisuus että rinnakkaisuus ovat välttämättömiä skaalautuvien järjestelmien rakentamisessa.
5. Tulevaisuuden turvaaminen: Kun laitteistotrendit suosivat edelleen moniytimisprosessoreja, kyky valjastaa rinnakkaisuus tulee yhä tarpeellisemmaksi.

Samanaikaisuus Pythonissa

Pythonissa voit saavuttaa samanaikaisuuden käyttämällä ketjutusta ja asynkronista ohjelmointia asyncio-kirjaston kanssa.

Threading Pythonissa

Threading on Pythonin samanaikaisuusmekanismi, jonka avulla voit luoda ja hallita tehtäviä yhdessä prosessissa. Säikeet sopivat tietyntyyppisiin tehtäviin, erityisesti sellaisiin, jotka ovat I/O-sidottuja ja voivat hyötyä samanaikaisesta suorituksesta.

Pythonin langoitus moduuli tarjoaa korkean tason käyttöliittymän säikeiden luomiseen ja hallintaan. Vaikka GIL (Global Interpreter Lock) rajoittaa säikeitä todellisen rinnakkaisuuden suhteen, ne voivat silti saavuttaa samanaikaisuuden lomittamalla tehtäviä tehokkaasti.

Alla oleva koodi näyttää esimerkin samanaikaisuuden toteutuksesta säikeiden avulla. Se käyttää Python-pyyntökirjastoa HTTP-pyynnön lähettämiseen, joka on yleinen I/O-estotehtävä. Se käyttää myös aikamoduuli suoritusajan laskemiseen.

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")

Kun käytät tätä ohjelmaa, sinun pitäisi nähdä, kuinka paljon nopeampia säikeitetyt pyynnöt ovat kuin peräkkäiset pyynnöt. Vaikka ero on vain sekunnin murto-osa, saat selkeän käsityksen suorituskyvyn parantumisesta, kun käytät säikeitä I/O-sidottuihin tehtäviin.

Asynkroninen ohjelmointi Asyncion kanssa

asyncio tarjoaa tapahtumasilmukan, joka hallitsee asynkronisia tehtäviä, joita kutsutaan korutiiniksi. Korutiinit ovat toimintoja, jotka voit keskeyttää ja jatkaa, joten ne sopivat ihanteellisesti I/O-sidottuihin tehtäviin. Kirjasto on erityisen hyödyllinen skenaarioissa, joissa tehtäviin liittyy ulkoisten resurssien, kuten verkkopyyntöjen, odottamista.

Voit muokata edellistä pyynnön lähetysesimerkkiä toimimaan asyncio:

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")

Koodia käyttämällä voit ladata verkkosivuja samanaikaisesti käyttämällä asyncio ja hyödyntää asynkronisia I/O-toimintoja. Tämä voi olla tehokkaampaa kuin ketjuttaminen I/O-sidottuissa tehtävissä.

Rinnakkaisuus Pythonissa

Voit toteuttaa rinnakkaisuuden käyttämällä Pythonin monikäsittely moduuli, jonka avulla voit hyödyntää täyden hyödyn moniytimisprosessoreista.

Monikäsittely Pythonissa

Pythonin monikäsittely moduuli tarjoaa tavan saavuttaa rinnakkaisuus luomalla erillisiä prosesseja, joista jokaisella on oma Python-tulkki ja muistitila. Tämä ohittaa tehokkaasti Global Interpreter Lock (GIL) -lukon, mikä tekee siitä sopivan suorittimeen sidottujen tehtävien suorittamiseen.

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()

Tässä esimerkissä monikäsittely synnyttää useita prosesseja, mikä mahdollistaa download_url toiminto toimii rinnakkain.

Milloin käyttää samanaikaisuutta tai rinnakkaisuutta

Valinta samanaikaisuuden ja rinnakkaisuuden välillä riippuu tehtäviesi luonteesta ja käytettävissä olevista laitteistoresursseista.

Voit käyttää samanaikaisuutta käsitellessäsi I/O-sidottuja tehtäviä, kuten tiedostojen lukeminen ja kirjoittaminen tai verkkopyyntöjen tekeminen ja kun muistirajoitukset ovat huolestuttavia.

Käytä moniprosessointia, kun sinulla on suorittimeen sidottuja tehtäviä, jotka voivat hyötyä todellisesta rinnakkaisuudesta ja kun tehtävien välillä on vahva eristys, jolloin yhden tehtävän epäonnistumisen ei pitäisi vaikuttaa muihin.

Hyödynnä samanaikaisuutta ja rinnakkaisuutta

Rinnakkaisuus ja samanaikaisuus ovat tehokkaita tapoja parantaa Python-koodisi reagointikykyä ja suorituskykyä. On tärkeää ymmärtää näiden käsitteiden erot ja valita tehokkain strategia.

Python tarjoaa työkalut ja moduulit, joita tarvitset tehdäksesi koodistasi tehokkaamman samanaikaisuuden tai rinnakkaisuuden avulla, riippumatta siitä, työskenteletkö prosessori- vai I/O-sidottujen prosessien kanssa.