Python Academy · Oppitunti

ThreadPoolExecutor

Suorita tehtäviä samanaikaisesti

Oppitunti 2/413 vaihetta

ThreadPoolExecutor on ilmainen Python Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Python Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Python Academy-kurssilla on yhteensä 4 oppituntia.

Miksi säiepooli

Säikeiden luominen ja niihin liittyminen manuaalisesti on työlästä. concurrent.futures.ThreadPoolExecutor hallinnoi puolestanne työntekijäsäikeiden poolia ja palauttaa tulokset selkeästi.

from concurrent.futures import ThreadPoolExecutor

def square(n):
    return n * n

with ThreadPoolExecutor() as ex:
    future = ex.submit(square, 5)
    print(future.result())

submit ja Future

submit() ajoittaa kutsun ja palauttaa heti Future-olion. Kutsukaa sen .result()-metodia saadaksenne arvon; kutsu odottaa, kunnes arvo on valmis.

from concurrent.futures import ThreadPoolExecutor

def greet(name):
    return 'hi ' + name

with ThreadPoolExecutor(max_workers=2) as ex:
    f1 = ex.submit(greet, 'Ana')
    f2 = ex.submit(greet, 'Bob')
    print(f1.result())
    print(f2.result())

map useille syötteille

executor.map(func, iterable) suorittaa funktion samanaikaisesti jokaiselle alkiolle ja tuottaa tulokset syötteiden järjestyksessä.

from concurrent.futures import ThreadPoolExecutor

def cube(n):
    return n ** 3

with ThreadPoolExecutor() as ex:
    results = ex.map(cube, range(5))
    print(list(results))

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

max_workers rajoittaa samanaikaisesti suoritettavien säikeiden määrää. I/O-sidonnaisessa työssä voitte käyttää useampia työntekijöitä kuin suorittimessa on ytimiä.

from concurrent.futures import ThreadPoolExecutor
import time

def io_task(n):
    time.sleep(0.05)
    return n

start = time.perf_counter()
with ThreadPoolExecutor(max_workers=4) as ex:
    print(list(ex.map(io_task, range(4))))
print('ran concurrently')

as_completed

as_completed(futures) tuottaa kunkin Future-olion heti, kun se valmistuu, lähetysjärjestyksestä riippumatta. Se sopii erinomaisesti tulosten käsittelyyn heti niiden valmistuttua.

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def work(n):
    time.sleep(0.01 * (3 - n))
    return n

with ThreadPoolExecutor() as ex:
    futures = [ex.submit(work, i) for i in range(3)]
    for f in as_completed(futures):
        print('finished', f.result())

Poikkeusten käsittely

Jos tehtävä nostaa poikkeuksen, se tallennetaan Future-olioon ja nostetaan uudelleen, kun kutsutte .result()-metodia. Ympäröikää tämä kutsu try/except-rakenteella.

from concurrent.futures import ThreadPoolExecutor

def risky(n):
    if n == 0:
        raise ValueError('cannot be zero')
    return 10 // n

with ThreadPoolExecutor() as ex:
    f = ex.submit(risky, 0)
    try:
        print(f.result())
    except ValueError as e:
        print('caught:', e)

Kuvaaminen useilla argumenteilla

map hyväksyy useita iteroitavia olioita ja yhdistää niiden alkiot argumenteiksi sisäänrakennetun map-funktion tavoin.

from concurrent.futures import ThreadPoolExecutor

def add(a, b):
    return a + b

with ThreadPoolExecutor() as ex:
    print(list(ex.map(add, [1, 2, 3], [10, 20, 30])))

Tulosten kerääminen sanakirjaan

Yleinen toimintamalli yhdistää kunkin Future-olion takaisin sen syötteeseen, jotta tiedätte, mikä tulos kuuluu millekin syötteelle as_completed-funktion kanssa työskennellessänne.

from concurrent.futures import ThreadPoolExecutor, as_completed

def length(word):
    return len(word)

words = ['cat', 'tiger', 'ox']
with ThreadPoolExecutor() as ex:
    future_to_word = {ex.submit(length, w): w for w in words}
    out = {}
    for f in as_completed(future_to_word):
        out[future_to_word[f]] = f.result()
print(sorted(out.items()))

Kontekstinhallinnan avulla sulkeminen

Kun käytätte executoria with-lohkon sisällä, se kutsuu shutdown()-metodia automaattisesti ja odottaa kaikkien odottavien tehtävien valmistumista.

from concurrent.futures import ThreadPoolExecutor

def job(n):
    return n * 2

with ThreadPoolExecutor() as ex:
    futures = [ex.submit(job, i) for i in range(3)]
print('all tasks done after the with block')
print([f.result() for f in futures])

Futuren tilan tarkistaminen

Future-olio tarjoaa metodit .done() ja .running(), joiden avulla voitte tarkastella edistymistä estämättä suoritusta.

from concurrent.futures import ThreadPoolExecutor

def quick(n):
    return n + 1

with ThreadPoolExecutor() as ex:
    f = ex.submit(quick, 41)
    result = f.result()
    print('done?', f.done())
    print('value:', result)

Milloin sitä kannattaa käyttää

ThreadPoolExecutor sopii erinomaisesti moniin pieniin I/O-sidonnaisiin tehtäviin, kuten HTTP-kutsuihin, tiedostojen lukemiseen ja tietokantakyselyihin. Käyttäkää CPU-sidonnaiseen työhön sen sijaan ProcessPoolExecutor-luokkaa.

from concurrent.futures import ThreadPoolExecutor

urls = ['a', 'b', 'c']

def fetch(u):
    return 'fetched ' + u

with ThreadPoolExecutor(max_workers=3) as ex:
    for r in ex.map(fetch, urls):
        print(r)

Pikatarkistus

Testatkaa, miten hyvin hallitsette ThreadPoolExecutorin.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte käyttämään ThreadPoolExecutoria:

submit() palauttaa Futuren, ja map() käy iteroitavan olion läpi järjestyksessä.
as_completed() palauttaa futuret niiden valmistuessa.
Poikkeukset tulevat esiin kutsuttaessa result()-metodia.
with-lohko huolehtii sulkemisesta.

Seuraavaksi: todellinen rinnakkaisuus multiprocessing-moduulilla.

Aloita maksutta

Opi Python tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 76
Oppitunnit: 320

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”ThreadPoolExecutor” ilmainen?

Kyllä – oppitunnin ”ThreadPoolExecutor” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Python Academy-kurssin, päivitä CoddyKit PROhon. Python Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”ThreadPoolExecutor”?

Suorita tehtäviä samanaikaisesti Harjoittelet Python Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Python Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Python Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”ThreadPoolExecutor”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Python Academy-oppitunnilla?

Kyllä. Jokainen Python Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Python Academy