ThreadPoolExecutor
Aufgaben gleichzeitig ausführen
ThreadPoolExecutor ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.
Warum ein Thread-Pool?
Threads manuell zu erstellen und auf ihren Abschluss zu warten ist mühsam. concurrent.futures.ThreadPoolExecutor verwaltet einen Pool von Worker-Threads für Sie und liefert Ergebnisse übersichtlich zurück.
from concurrent.futures import ThreadPoolExecutor
def square(n):
return n * n
with ThreadPoolExecutor() as ex:
future = ex.submit(square, 5)
print(future.result())submit und Future
submit() plant einen Aufruf ein und gibt sofort ein Future zurück. Sie rufen .result() darauf auf, um den Wert zu erhalten; dieser Aufruf blockiert, bis der Wert verfügbar ist.
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 für viele Eingaben
executor.map(func, iterable) führt die Funktion nebenläufig für jedes Element aus und liefert die Ergebnisse in der Eingabereihenfolge.
from concurrent.futures import ThreadPoolExecutor
def cube(n):
return n ** 3
with ThreadPoolExecutor() as ex:
results = ex.map(cube, range(5))
print(list(results))Die Anzahl der Worker steuern
max_workers begrenzt, wie viele Threads gleichzeitig ausgeführt werden. Bei I/O-bound-Arbeit können Sie mehr Worker als CPU-Kerne verwenden.
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) liefert jedes Future unmittelbar nach dessen Abschluss, unabhängig von der Reihenfolge der Einreichung. Das ist ideal, um Ergebnisse zu verarbeiten, sobald sie eintreffen.
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())Ausnahmen behandeln
Wenn eine Aufgabe eine Ausnahme auslöst, wird diese in ihrem Future gespeichert und beim Aufruf von .result() erneut ausgelöst. Umschließen Sie diesen Aufruf mit 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)Abbilden mit mehreren Argumenten
map akzeptiert mehrere Iterables und fügt sie wie die eingebaute Funktion map zu Argumenten zusammen.
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])))Ergebnisse in einem Dict sammeln
Ein häufig verwendetes Muster ordnet jedes Future wieder seiner Eingabe zu. So wissen Sie bei der Verwendung von as_completed, welches Ergebnis zu welcher Eingabe gehört.
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()))Beenden mit einem Context Manager
Wenn Sie den Executor in einem with-Block verwenden, wird shutdown() automatisch aufgerufen und auf den Abschluss aller ausstehenden Aufgaben gewartet.
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])Den Zustand eines Future prüfen
Ein Future stellt .done() und .running() bereit, sodass Sie den Fortschritt prüfen können, ohne zu blockieren.
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)Wann Sie ihn verwenden sollten
ThreadPoolExecutor eignet sich ideal für viele kleine I/O-bound-Aufgaben: HTTP-Aufrufe, Dateizugriffe und Datenbankabfragen. Verwenden Sie für CPU-bound-Arbeit stattdessen 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)Kurzer Test
Testen Sie Ihr Verständnis von ThreadPoolExecutor.
Rückblick
Sie haben ThreadPoolExecutor kennengelernt:
submit()gibt ein Future zurück;map()arbeitet die Elemente eines Iterables in der vorgegebenen Reihenfolge ab.as_completed()liefert Futures, sobald sie abgeschlossen sind.- Ausnahmen werden über
result()sichtbar. - Der
with-Block übernimmt das Herunterfahren.
Als Nächstes: echter Parallelismus mit multiprocessing.
Häufig gestellte Fragen
Ist die Lektion „ThreadPoolExecutor“ kostenlos?
Ja — der vollständige Text von „ThreadPoolExecutor“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „ThreadPoolExecutor“?
Aufgaben gleichzeitig ausführen Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Python Academy zu starten?
Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „ThreadPoolExecutor“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?
Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.