Pythonin rinnakkaisuuden vapauttaminen: ThreadPoolExecutor vs. ProcessPoolExecutor

Pythonilla, vaikka se on monipuolinen ja laajalti käytetty ohjelmointikieli, on tiettyjä rajoituksia todellisen rinnakkaisuuden suhteen globaalin tulkintalukon (GIL) takia. concurrent.futures-moduuli tarjoaa korkean tason rajapinnan asynkronisesti suoritettaville kutsuttaville, tarjoten tavan kiertää joitakin näistä rajoituksista ja parantaa suorituskykyä tietyntyyppisille tehtäville. Tämä moduuli tarjoaa kaksi keskeistä luokkaa: ThreadPoolExecutor ja ProcessPoolExecutor. Tämä kattava opas tutkii molempia, korostaen niiden eroja, vahvuuksia ja heikkouksia, ja tarjoaa käytännön esimerkkejä auttamaan sinua valitsemaan oikean suorittimen tarpeisiisi.

Rinnakkaisuuden ja rinnakkaissuorituksen ymmärtäminen

Ennen kuin sukellamme kunkin suorittimen yksityiskohtiin, on ratkaisevan tärkeää ymmärtää rinnakkaisuuden ja rinnakkaissuorituksen käsitteet. Näitä termejä käytetään usein synonyymeinä, mutta niillä on selkeät merkitykset:

• Rinnakkaisuus: Käsittelee useiden tehtävien hallintaa samanaikaisesti. Kyse on koodin rakentamisesta siten, että se käsittelee useita asioita näennäisesti samanaikaisesti, vaikka ne todellisuudessa lomittuvat yhdellä prosessoriytimellä. Ajattele sitä kokkina, joka hallitsee useita kattiloita yhdellä liedellä – ne eivät kaikki kiehu samalla hetkellä, mutta kokki hallitsee niitä kaikkia.
• Rinnakkaissuoritus: Käsittää itse asiassa useiden tehtävien suorittamisen *samanaikaisesti*, tyypillisesti hyödyntämällä useita prosessoriytimiä. Tämä on kuin useita kokkeja, joista jokainen työskentelee eri osan ateriaa samanaikaisesti.

Pythonin GIL estää suurelta osin todellisen rinnakkaissuorituksen CPU-sidonnaisille tehtäville säikeitä käytettäessä. Tämä johtuu siitä, että GIL sallii vain yhden säikeen hallita Python-tulkkiä kerrallaan. Kuitenkin I/O-sidonnaisille tehtäville, joissa ohjelma viettää suurimman osan ajastaan odottamalla ulkoisia toimintoja, kuten verkostopyyntöjä tai levylukemista, säikeet voivat silti tarjota merkittäviä suorituskyvyn parannuksia sallimalla muiden säikeiden suorittaa, kun yksi odottaa.

Esittelyssä `concurrent.futures`-moduuli

concurrent.futures-moduuli yksinkertaistaa tehtävien asynkronisen suorittamisen prosessia. Se tarjoaa korkean tason rajapinnan säikeiden ja prosessien kanssa työskentelyyn, abstrahoimalla pois suurimman osan niiden suoraan hallintaan liittyvästä monimutkaisuudesta. Ydin on "suoritin", joka hallitsee lähetettyjen tehtävien suorittamista. Kaksi ensisijaista suoritinta ovat:

• ThreadPoolExecutor: Käyttää säiepoolia tehtävien suorittamiseen. Sopii I/O-sidonnaisille tehtäville.
• ProcessPoolExecutor: Käyttää prosessipoolia tehtävien suorittamiseen. Sopii CPU-sidonnaisille tehtäville.

ThreadPoolExecutor: Säikeiden hyödyntäminen I/O-sidonnaisille tehtäville

ThreadPoolExecutor luo työsäikeiden poolin tehtävien suorittamiseksi. GIL:n vuoksi säikeet eivät ole ihanteellisia laskennallisesti intensiivisille toimille, jotka hyötyvät todellisesta rinnakkaissuorituksesta. Ne kuitenkin loistavat I/O-sidonnaisissa skenaarioissa. Tutustutaanpa sen käyttöön:

Peruskäyttö

Tässä on yksinkertainen esimerkki ThreadPoolExecutor-käytöstä useiden verkkosivujen lataamiseen samanaikaisesti:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]

def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Nosta HTTPError huonoille vastauksille (4xx tai 5xx)
        print(f"Ladattu {url}: {len(response.content)} tavua")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Virhe ladattaessa {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Lähetä jokainen URL suorittimelle
    futures = [executor.submit(download_page, url) for url in urls]

    # Odota kaikkien tehtävien valmistumista
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Yhteensä ladattuja tavuja: {total_bytes}")
print(f"Käytetty aika: {time.time() - start_time:.2f} sekuntia")

Selitys:

1. Tuomme tarvittavat moduulit: concurrent.futures, requests ja time.
2. Määrittelemme luettelon ladattavista URL-osoitteista.
3. download_page-funktio noutaa annetun URL-osoitteen sisällön. Virheenkäsittely sisältyy käyttämällä `try...except` ja `response.raise_for_status()` mahdollisten verkko-ongelmien havaitsemiseksi.
4. Luomme ThreadPoolExecutor-olion, jossa on enintään 4 työsäiettä. max_workers-argumentti ohjaa enimmäismäärän säikeitä, joita voidaan käyttää samanaikaisesti. Sen asettaminen liian korkeaksi ei välttämättä aina paranna suorituskykyä, erityisesti I/O-sidonnaisissa tehtävissä, joissa verkon kaistanleveys on usein pullonkaula.
5. Käytämme listanymmärrystä lähettääksemme jokaisen URL-osoitteen suorittimelle käyttäen executor.submit(download_page, url). Tämä palauttaa Future-objektin jokaiselle tehtävälle.
6. Funktio concurrent.futures.as_completed(futures) palauttaa iteraattorin, joka tuottaa tulevaisuuksia, kun ne valmistuvat. Tämä välttää odottamasta kaikkien tehtävien valmistumista ennen tulosten käsittelyä.
7. Iteroimme valmistuneiden tulevaisuuksien läpi ja noudamme jokaisen tehtävän tuloksen käyttämällä future.result(), summaamalla ladattujen tavujen kokonaismäärän. Virheenkäsittely download_page-funktion sisällä varmistaa, että yksittäiset virheet eivät kaada koko prosessia.
8. Lopuksi tulostamme ladattujen tavujen kokonaismäärän ja käytetyn ajan.

ThreadPoolExecutor-suorittimen edut

• Yksinkertaistettu rinnakkaisuus: Tarjoaa selkeän ja helppokäyttöisen rajapinnan säikeiden hallintaan.
• I/O-sidottu suorituskyky: Erinomainen tehtäville, jotka viettävät huomattavan määrän aikaa odottaen I/O-toimintoja, kuten verkostopyyntöjä, tiedostolukemisia tai tietokantakyselyitä.
• Pienempi ylikuormitus: Säikeillä on yleensä pienempi ylikuormitus verrattuna prosesseihin, mikä tekee niistä tehokkaampia tehtäville, jotka sisältävät usein tapahtuvaa kontekstin vaihtoa.

ThreadPoolExecutor-suorittimen rajoitukset

• GIL-rajoitus: GIL rajoittaa todellista rinnakkaisuutta CPU-sidonnaisille tehtäville. Vain yksi säie voi suorittaa Python-tavukoodia kerrallaan, mikä kumoaa useiden ytimien hyödyt.
• Virheenkorjauksen monimutkaisuus: Monisäikeisten sovellusten virheenkorjaus voi olla haastavaa kilpailuolosuhteiden ja muiden rinnakkaisuuteen liittyvien ongelmien vuoksi.

ProcessPoolExecutor: Moniprosessoinnin vapauttaminen CPU-sidonnaisille tehtäville

ProcessPoolExecutor voittaa GIL-rajoituksen luomalla työntekijäprosessien poolin. Jokaisella prosessilla on oma Python-tulkkinsa ja muistitilansa, mikä mahdollistaa todellisen rinnakkaissuorituksen moniydinjärjestelmissä. Tämä tekee siitä ihanteellisen CPU-sidonnaisille tehtäville, jotka sisältävät raskaita laskutoimituksia.

Peruskäyttö

Harkitse laskennallisesti intensiivistä tehtävää, kuten neliöiden summan laskemista suurelle määrälle numeroita. Tässä on, kuinka ProcessPoolExecutor-suorittimella rinnakkaistetaan tämä tehtävä:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Prosessin tunnus: {pid}, Lasketaan neliöiden summaa väliltä {start} - {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Tärkeä rekursiivisen käynnistyksen välttämiseksi joissakin ympäristöissä
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Neliöiden kokonaissumma: {total_sum}")
    print(f"Käytetty aika: {time.time() - start_time:.2f} sekuntia")

Selitys:

1. Määritämme funktion sum_of_squares, joka laskee neliöiden summan tietylle numerovälille. Sisällytämme `os.getpid()` nähdäksemme, mikä prosessi suorittaa kutakin aluetta.
2. Määritämme alueen koon ja käytettävien prosessien määrän. ranges-lista luodaan jakamaan kokonaislaskenta-alue pienempiin osiin, yksi kullekin prosessille.
3. Luomme ProcessPoolExecutor-olion määritetyllä määrällä työntekijäprosesseja.
4. Lähetämme jokaisen alueen suorittimelle käyttämällä executor.submit(sum_of_squares, start, end).
5. Keräämme tulokset jokaisesta tulevaisuudesta käyttämällä future.result().
6. Summaamme kaikkien prosessien tulokset saadaksemme lopullisen summan.

Tärkeä huomautus: Kun käytät ProcessPoolExecutor-suoritinta, erityisesti Windowsissa, sinun tulee sulkea suorittimen luova koodi if __name__ == "__main__": -lohkoon. Tämä estää rekursiivisen prosessin luomisen, mikä voi johtaa virheisiin ja odottamattomaan toimintaan. Tämä johtuu siitä, että moduuli tuodaan uudelleen jokaisessa lapsiprosessissa.

ProcessPoolExecutor-suorittimen edut

• Todellinen rinnakkaissuoritus: Ylittää GIL-rajoituksen, mahdollistaen todellisen rinnakkaissuorituksen moniydinjärjestelmissä CPU-sidonnaisille tehtäville.
• Parannettu suorituskyky CPU-sidonnaisille tehtäville: Merkittäviä suorituskyvyn parannuksia voidaan saavuttaa laskennallisesti intensiivisille operaatioille.
• Kestävyys: Jos yksi prosessi kaatuu, se ei välttämättä kaada koko ohjelmaa, koska prosessit on eristetty toisistaan.

ProcessPoolExecutor-suorittimen rajoitukset

• Suurempi ylikuormitus: Prosessien luomisella ja hallinnalla on suurempi ylikuormitus verrattuna säikeisiin.
• Prosessien välinen viestintä: Tietojen jakaminen prosessien välillä voi olla monimutkaisempaa ja vaatii prosessien välisten viestintämekanismien (IPC), mikä voi lisätä ylikuormitusta.
• Muistijalanjälki: Jokaisella prosessilla on oma muistitilansa, mikä voi lisätä sovelluksen kokonaismuistijalanjälkeä. Suurten tietomäärien välittäminen prosessien välillä voi tulla pullonkaulaksi.

Oikean suorittimen valinta: ThreadPoolExecutor vs. ProcessPoolExecutor

Avain ThreadPoolExecutor- ja ProcessPoolExecutor-suorittimien välillä valintaan piilee tehtäviesi luonteen ymmärtämisessä:

• I/O-sidonnaiset tehtävät: Jos tehtäväsi viettävät suurimman osan ajastaan odottaen I/O-toimintoja (esim. verkostopyyntöjä, tiedostolukemista, tietokantakyselyjä), ThreadPoolExecutor on yleensä parempi valinta. GIL on vähemmän pullonkaula näissä skenaarioissa, ja säikeiden pienempi ylikuormitus tekee niistä tehokkaampia.
• CPU-sidonnaiset tehtävät: Jos tehtäväsi ovat laskennallisesti intensiivisiä ja hyödyntävät useita ytimiä, ProcessPoolExecutor on oikea tapa. Se ohittaa GIL-rajoituksen ja mahdollistaa todellisen rinnakkaissuorituksen, mikä johtaa merkittäviin suorituskyvyn parannuksiin.

Tässä on taulukko, joka tiivistää keskeiset erot:

Ominaisuus	ThreadPoolExecutor	ProcessPoolExecutor
Rinnakkaisuusmalli	Monisäikeisyys	Moniprosessointi
GIL-vaikutus	Rajoitettu GIL:n mukaan	Ohittaa GIL:n
Sopii	I/O-sidonnaiset tehtävät	CPU-sidonnaiset tehtävät
Ylikuormitus	Pienempi	Suurempi
Muistijalanjälki	Pienempi	Suurempi
Prosessien välinen viestintä	Ei vaadita (säikeet jakavat muistin)	Vaaditaan tietojen jakamiseen
Kestävyys	Vähemmän kestävä (kaatuminen voi vaikuttaa koko prosessiin)	Kestävä (prosessit on eristetty)

Edistyneitä tekniikoita ja huomioitavia asioita

Tehtävien lähettäminen argumenttien kanssa

Molemmat suorittimet antavat sinun välittää argumentteja suoritettavalle funktiolle. Tämä tapahtuu submit()-metodin avulla:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

Poikkeuksien käsittely

Suoritetussa funktiossa nostetut poikkeukset eivät automaattisesti leviää pääsäikeeseen tai -prosessiin. Sinun on nimenomaisesti käsiteltävä ne noutaessasi Future-olion tuloksen:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"Ilmeni poikkeus: {e}")

`map`-käyttö yksinkertaisille tehtäville

Yksinkertaisille tehtäville, joissa haluat soveltaa samaa funktiota syötejonoon, map()-metodi tarjoaa ytimekkään tavan lähettää tehtäviä:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

Työntekijöiden lukumäärän hallinta

max_workers-argumentti sekä ThreadPoolExecutor- että ProcessPoolExecutor-suorittimissa ohjaa enimmäismäärän säikeitä tai prosesseja, joita voidaan käyttää samanaikaisesti. Oikean arvon valitseminen max_workers-argumentille on tärkeää suorituskyvyn kannalta. Hyvä lähtökohta on järjestelmässäsi käytettävissä olevien CPU-ydinten määrä. Kuitenkin, I/O-sidonnaisille tehtäville voit hyötyä käyttämällä enemmän säikeitä kuin ytimiä, koska säikeet voivat vaihtaa muihin tehtäviin odottaessaan I/O-toimintoja. Kokeilu ja profilointi ovat usein tarpeen optimaalisen arvon määrittämiseksi.

Edistymisen seuranta

concurrent.futures-moduuli ei tarjoa sisäänrakennettuja mekanismeja tehtävien edistymisen suoraan seuraamiseen. Voit kuitenkin toteuttaa oman edistymisen seurannan käyttämällä takaisinkutsuja tai jaettuja muuttujia. Kirjastoja, kuten `tqdm`, voidaan integroida edistymispalkkien näyttämiseksi.

Tosielämän esimerkkejä

Harkitaanpa joitain tosielämän skenaarioita, joissa ThreadPoolExecutor ja ProcessPoolExecutor voidaan soveltaa tehokkaasti:

• Verkkosivujen kerääminen: Useiden verkkosivujen lataaminen ja jäsentäminen samanaikaisesti käyttämällä ThreadPoolExecutor-suoritinta. Jokainen säie voi käsitellä eri verkkosivua, mikä parantaa yleistä keräysnopeutta. Ole tietoinen verkkosivuston käyttöehdoista ja vältä niiden palvelimien ylikuormittamista.
• Kuvankäsittely: Kuvien suodattimien tai muunnosten soveltaminen suureen joukkoon kuvia käyttämällä ProcessPoolExecutor-suoritinta. Jokainen prosessi voi käsitellä eri kuvaa, hyödyntäen useita ytimiä nopeampaan käsittelyyn. Harkitse kirjastoja, kuten OpenCV, tehokkaaseen kuvankäsittelyyn.
• Data-analyysi: Monimutkaisten laskelmien suorittaminen suurilla tietojoukoilla käyttämällä ProcessPoolExecutor-suoritinta. Jokainen prosessi voi analysoida osajoukon tiedoista, mikä lyhentää kokonaisanalyysiaikaa. Pandas ja NumPy ovat suosittuja kirjastoja data-analyysiin Pythonissa.
• Koneoppiminen: Koneoppimismallien kouluttaminen käyttämällä ProcessPoolExecutor-suoritinta. Jotkin koneoppimisalgoritmit voidaan rinnakkaistaa tehokkaasti, mikä mahdollistaa nopeammat koulutusajat. Kirjastot, kuten scikit-learn ja TensorFlow, tarjoavat tuen rinnakkaistamiseen.
• Videoiden koodaus: Videotiedostojen muuntaminen eri muotoihin käyttämällä ProcessPoolExecutor-suoritinta. Jokainen prosessi voi koodata eri videosegmentin, mikä nopeuttaa kokonaiskoodausprosessia.

Globaalit näkökohdat

Kun kehität samanaikaisia sovelluksia globaalille yleisölle, on tärkeää ottaa huomioon seuraavat asiat:

• Aikavyöhykkeet: Ole tietoinen aikavyöhykkeistä käsitellessäsi aikaherkkiä toimintoja. Käytä kirjastoja, kuten pytz, aikavyöhykemuunnosten käsittelyyn.
• Lokaalit: Varmista, että sovelluksesi käsittelee eri lokaaleja oikein. Käytä kirjastoja, kuten locale, numerojen, päivämäärien ja valuuttojen muotoiluun käyttäjän lokaalin mukaisesti.
• Merkkien koodaukset: Käytä Unicodea (UTF-8) oletusmerkkien koodauksena tukeaksesi laajaa valikoimaa kieliä.
• Kansainvälistyminen (i18n) ja lokalisaatio (l10n): Suunnittele sovelluksesi niin, että se on helposti kansainvälistettävissä ja lokalisoitavissa. Käytä gettextiä tai muita käännöskirjastoja tarjotaksesi käännöksiä eri kielille.
• Verkon viive: Ota huomioon verkon viive, kun kommunikoit etäpalveluiden kanssa. Toteuta sopivat aikakatkaisut ja virheenkäsittely varmistaaksesi, että sovelluksesi kestää verkko-ongelmia. Palvelimien maantieteellinen sijainti voi vaikuttaa viiveeseen huomattavasti. Harkitse Content Delivery Networks (CDN) -verkkojen käyttämistä parantamaan suorituskykyä eri alueiden käyttäjille.

Johtopäätös

concurrent.futures-moduuli tarjoaa tehokkaan ja kätevän tavan ottaa rinnakkaisuus ja rinnakkaissuoritus Python-sovelluksiisi. Ymmärtämällä ThreadPoolExecutor- ja ProcessPoolExecutor-suorittimien väliset erot ja harkitsemalla huolellisesti tehtäviesi luonnetta, voit merkittävästi parantaa koodisi suorituskykyä ja reagointikykyä. Muista profiloida koodisi ja kokeilla eri asetuksia löytääksesi optimaaliset asetukset juuri sinun käyttötapauksellesi. Ole myös tietoinen GIL:n rajoituksista ja monisäikeisen ja moniprosessointiohjelmoinnin mahdollisista monimutkaisuuksista. Huolellisella suunnittelulla ja toteutuksella voit vapauttaa rinnakkaisuuden täyden potentiaalin Pythonissa ja luoda kestäviä ja skaalautuvia sovelluksia globaalille yleisölle.