Python Academy · leksjon

ThreadPoolExecutor

Kjør oppgaver samtidig

Leksjon 2 av 413 trinn

ThreadPoolExecutor er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Python Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hvorfor en trådpool?

Det er omstendelig å opprette og koble sammen tråder manuelt. concurrent.futures.ThreadPoolExecutor håndterer en pool med arbeidstråder for Dem og returnerer resultater på en ryddig måte.

from concurrent.futures import ThreadPoolExecutor

def square(n):
    return n * n

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

submit og Future

submit() planlegger et kall og returnerer umiddelbart en Future. Kall .result() på den for å hente verdien. Da blokkeres kjøringen til verdien er klar.

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 for mange inndata

executor.map(func, iterable) kjører funksjonen på hvert element samtidig og gir resultater i samme rekkefølge som inndataene.

from concurrent.futures import ThreadPoolExecutor

def cube(n):
    return n ** 3

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

Kontrollere antall arbeidstråder

max_workers begrenser hvor mange tråder som kjører samtidig. For I/O-bundet arbeid kan De bruke flere arbeidstråder enn antallet CPU-kjerner.

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) gir fra seg hver Future i det øyeblikket den blir ferdig, uavhengig av rekkefølgen de ble sendt inn i. Dette er svært nyttig for å behandle resultater så snart de kommer.

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

Håndtere unntak

Hvis en oppgave utløser et unntak, lagres unntaket i Future-objektet og utløses på nytt når De kaller .result(). Pakk dette kallet inn i try/except.

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)

Map med flere argumenter

map godtar flere itererbare verdier og setter dem sammen som argumenter, på samme måte som den innebygde map-funksjonen.

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

Samle resultater i en dict

Et vanlig mønster er å knytte hver Future tilbake til inndataene, slik at De vet hvilket resultat som hører til hva når De bruker as_completed.

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

Avslutning med kontekstbehandler

Når De bruker executor-en i en with-blokk, kalles shutdown() automatisk, og programmet venter til alle ventende oppgaver er ferdige.

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

Kontrollere tilstanden til en Future

En Future har .done() og .running(), slik at De kan kontrollere fremdriften uten å blokkere.

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)

Når bør De bruke den

ThreadPoolExecutor egner seg godt til mange små I/O-bundne oppgaver: HTTP-kall, lesing av filer og databaseforespørsler. Bruk ProcessPoolExecutor for CPU-bundet arbeid i stedet.

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)

Hurtigsjekk

Test forståelsen din av ThreadPoolExecutor.

Besvar den i den interaktive leksjonen

Oppsummering

Du har lært om ThreadPoolExecutor:

submit() returnerer en Future; map() kjører over en itererbar sekvens i riktig rekkefølge.
as_completed() gir futures etter hvert som de blir ferdige.
Unntak blir synlige via result().
with-blokken håndterer avslutningen.

Neste: ekte parallellitet med multiprocessing.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 76
Leksjoner: 320

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «ThreadPoolExecutor» gratis?

Ja – hele teksten i «ThreadPoolExecutor» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Python Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «ThreadPoolExecutor»?

Kjør oppgaver samtidig Du øver på Python Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Python Academy?

Ingen tidligere erfaring er nødvendig. Python Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «ThreadPoolExecutor»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Python Academy-leksjonen?

Ja. Alle Python Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Python Academy