ThreadPoolExecutor
Voer taken gelijktijdig uit
ThreadPoolExecutor is een gratis Python Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.
Waarom een threadpool?
Threads handmatig maken en samenvoegen is omslachtig. concurrent.futures.ThreadPoolExecutor beheert een pool met werkthreads voor je en levert resultaten netjes terug.
from concurrent.futures import ThreadPoolExecutor
def square(n):
return n * n
with ThreadPoolExecutor() as ex:
future = ex.submit(square, 5)
print(future.result())submit en Future
submit() plant een aanroep in en retourneert onmiddellijk een Future. Je roept .result() daarop aan om de waarde op te halen; de aanroep blokkeert totdat die beschikbaar is.
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 voor veel invoerwaarden
executor.map(func, iterable) voert de functie gelijktijdig uit voor elk item en levert de resultaten in invoervolgorde.
from concurrent.futures import ThreadPoolExecutor
def cube(n):
return n ** 3
with ThreadPoolExecutor() as ex:
results = ex.map(cube, range(5))
print(list(results))Het aantal werkthreads beheren
max_workers begrenst hoeveel threads er tegelijk worden uitgevoerd. Voor I/O-gebonden werk kun je meer werkthreads gebruiken dan er CPU-kernen zijn.
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) levert elke Future op zodra deze klaar is, ongeacht de volgorde waarin deze is ingepland. Dat is ideaal om resultaten te verwerken zodra ze binnenkomen.
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())Uitzonderingen afhandelen
Als een taak een uitzondering opwerpt, wordt die opgeslagen in de bijbehorende Future en opnieuw opgegooid wanneer je .result() aanroept. Plaats die aanroep in een try/except-blok.
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)Mappen met meerdere argumenten
map accepteert meerdere itereerbare bronnen en gebruikt de elementen daarvan als argumenten, net als de ingebouwde functie map.
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])))Resultaten in een woordenboek verzamelen
Een veelgebruikt patroon koppelt elke Future terug aan de bijbehorende invoer, zodat je bij het gebruik van as_completed weet welk resultaat bij welke invoer hoort.
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()))Afsluiten met een contextmanager
Als je de uitvoerder in een with-blok gebruikt, wordt shutdown() automatisch aangeroepen en wordt gewacht totdat alle openstaande taken zijn voltooid.
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])De toestand van Future controleren
Een Future biedt .done() en .running(), zodat je de voortgang kunt controleren zonder te blokkeren.
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)Wanneer gebruik je dit?
ThreadPoolExecutor is ideaal voor veel kleine I/O-gebonden taken: HTTP-aanroepen, bestanden lezen en databankquery's. Gebruik voor CPU-gebonden werk in plaats daarvan ProcessPoolExecutor.
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)Korte controle
Toets je begrip van ThreadPoolExecutor.
Samenvatting
Je hebt ThreadPoolExecutor geleerd:
submit()geeft een Future terug;map()voert de functie in volgorde uit op een itereerbaar object.as_completed()levert Future-objecten op zodra ze klaar zijn.- Uitzonderingen worden zichtbaar via
result(). - Het
with-blok handelt het afsluiten af.
Volgende: echte paralleliteit met multiprocessing.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 76
- Lessen
- 320
Veelgestelde vragen
Is de les “ThreadPoolExecutor” gratis?
Ja — de volledige tekst van “ThreadPoolExecutor” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.
Wat leer ik in “ThreadPoolExecutor”?
Voer taken gelijktijdig uit Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Python Academy te beginnen?
Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “ThreadPoolExecutor”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Python Academy?
Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Threads en de GIL
- ThreadPoolExecutor
- Basisprincipes van multiprocessing
- Gegevens veilig delen