Executor

Executor ist eine abstrakte Klasse, die Methoden zur asynchronen Ausführung von Aufrufen bereitstellt.

submit(fn, *args, **kwargs)

Plant den Aufrufbaren zur Ausführung als fn(*args, **kwargs) und gibt eine Future-Instanz zurück, die die Ausführung des Aufrufbaren darstellt.

Dies ist eine abstrakte Methode und muss von Executor-Unterklassen implementiert werden.

map(func, *iterables, timeout=None)

Entspricht map(func, *iterables), aber func wird asynchron ausgeführt und mehrere Aufrufe von func können gleichzeitig erfolgen. Der zurückgegebene Iterator löst einen TimeoutError aus, wenn __next__() aufgerufen wird und das Ergebnis nicht innerhalb von timeout Sekunden nach dem ursprünglichen Aufruf von map() verfügbar ist. Wenn timeout nicht angegeben oder None ist, gibt es keine Wartezeitbegrenzung. Wenn ein Aufruf eine Ausnahme auslöst, wird diese Ausnahme ausgelöst, wenn ihr Wert aus dem Iterator abgerufen wird.

shutdown(wait=True)

Signalisiert dem Executor, dass er alle verwendeten Ressourcen freigeben soll, sobald die aktuell ausstehenden Futures ausgeführt sind. Aufrufe von Executor.submit und Executor.map, die nach shutdown erfolgen, lösen einen RuntimeError aus.

Wenn wait True ist, gibt diese Methode erst zurück, wenn alle ausstehenden Futures ausgeführt sind und die dem Executor zugeordneten Ressourcen freigegeben wurden. Wenn wait False ist, gibt diese Methode sofort zurück und die dem Executor zugeordneten Ressourcen werden freigegeben, sobald alle ausstehenden Futures ausgeführt sind. Unabhängig vom Wert von wait wird das gesamte Python-Programm erst beendet, wenn alle ausstehenden Futures ausgeführt sind.

Wenn ein Executor als Kontextmanager verwendet wird, ruft __exit__ Executor.shutdown(wait=True) auf.

ProcessPoolExecutor

Die Klasse ProcessPoolExecutor ist eine Executor-Unterklasse, die einen Pool von Prozessen zur asynchronen Ausführung von Aufrufen verwendet. Die an ProcessPoolExecutor.submit übergebenen Aufrufbaren und Argumente müssen gemäß den gleichen Einschränkungen wie das Modul `multiprocessing` picklebar sein.

Aufrufe von Executor- oder Future-Methoden innerhalb eines an einen ProcessPoolExecutor übergebenen Aufrufbaren führen zu einem Deadlock.

__init__(max_workers)

Führt Aufrufe asynchron mithilfe eines Pools von höchstens max_workers Prozessen aus. Wenn max_workers None ist oder nicht angegeben wird, werden so viele Worker-Prozesse erstellt, wie der Rechner Prozessoren hat.

ThreadPoolExecutor

Die Klasse ThreadPoolExecutor ist eine Executor-Unterklasse, die einen Pool von Threads zur asynchronen Ausführung von Aufrufen verwendet.

Es kann zu Deadlocks kommen, wenn der Aufrufbare, der mit einem Future verbunden ist, auf die Ergebnisse eines anderen Future wartet. Zum Beispiel

import time
def wait_on_b():
    time.sleep(5)
    print(b.result())  # b will never complete because it is waiting on a.
    return 5

def wait_on_a():
    time.sleep(5)
    print(a.result())  # a will never complete because it is waiting on b.
    return 6


executor = ThreadPoolExecutor(max_workers=2)
a = executor.submit(wait_on_b)
b = executor.submit(wait_on_a)

Und

def wait_on_future():
    f = executor.submit(pow, 5, 2)
    # This will never complete because there is only one worker thread and
    # it is executing this function.
    print(f.result())

executor = ThreadPoolExecutor(max_workers=1)
executor.submit(wait_on_future)

__init__(max_workers)

Führt Aufrufe asynchron mithilfe eines Pools von höchstens max_workers Threads aus.

Future-Objekte

Die Klasse Future kapselt die asynchrone Ausführung eines Aufrufbaren. Future-Instanzen werden von Executor.submit zurückgegeben.

cancel()

Versucht, den Aufruf abzubrechen. Wenn der Aufruf gerade ausgeführt wird, kann er nicht abgebrochen werden und die Methode gibt False zurück, andernfalls wird der Aufruf abgebrochen und die Methode gibt True zurück.

cancelled()

Gibt True zurück, wenn der Aufruf erfolgreich abgebrochen wurde.

running()

Gibt True zurück, wenn der Aufruf gerade ausgeführt wird und nicht abgebrochen werden kann.

done()

Gibt True zurück, wenn der Aufruf erfolgreich abgebrochen oder die Ausführung beendet wurde.

result(timeout=None)

Gibt den vom Aufruf zurückgegebenen Wert zurück. Wenn der Aufruf noch nicht abgeschlossen ist, wartet diese Methode bis zu timeout Sekunden. Wenn der Aufruf in timeout Sekunden nicht abgeschlossen ist, wird ein TimeoutError ausgelöst. Wenn timeout nicht angegeben oder None ist, gibt es keine Wartezeitbegrenzung.

Wenn das Future vor dem Abschluss abgebrochen wird, wird CancelledError ausgelöst.

Wenn der Aufruf eine Ausnahme ausgelöst hat, löst diese Methode dieselbe Ausnahme aus.

exception(timeout=None)

Gibt die vom Aufruf ausgelöste Ausnahme zurück. Wenn der Aufruf noch nicht abgeschlossen ist, wartet diese Methode bis zu timeout Sekunden. Wenn der Aufruf in timeout Sekunden nicht abgeschlossen ist, wird ein TimeoutError ausgelöst. Wenn timeout nicht angegeben oder None ist, gibt es keine Wartezeitbegrenzung.

Wenn das Future vor dem Abschluss abgebrochen wird, wird CancelledError ausgelöst.

Wenn der Aufruf ohne Ausnahme abgeschlossen wurde, wird None zurückgegeben.

add_done_callback(fn)

Hängt eine aufrufbare Funktion fn an das Future an, die aufgerufen wird, wenn das Future abgebrochen wird oder seine Ausführung beendet hat. fn wird mit dem Future als einzigem Argument aufgerufen.

Hinzugefügte Aufrufbare werden in der Reihenfolge aufgerufen, in der sie hinzugefügt wurden, und immer in einem Thread aufgerufen, der zum Prozess gehört, der sie hinzugefügt hat. Wenn der Aufrufbare eine Exception auslöst, wird diese protokolliert und ignoriert. Wenn der Aufrufbare eine andere BaseException auslöst, ist das Verhalten undefiniert.

Wenn das Future bereits abgeschlossen oder abgebrochen wurde, wird fn sofort aufgerufen.

Modulfunktionen

wait(fs, timeout=None, return_when=ALL_COMPLETED)

Wartet auf den Abschluss der Future-Instanzen (möglicherweise erstellt von verschiedenen Executor-Instanzen), die durch fs gegeben sind. Gibt ein benanntes 2-Tupel von Mengen zurück. Die erste Menge, genannt „done“, enthält die Futures, die vor Abschluss des Wartens abgeschlossen wurden (fertig oder abgebrochen). Die zweite Menge, genannt „not_done“, enthält nicht abgeschlossene Futures.

timeout kann verwendet werden, um die maximale Wartezeit in Sekunden zu steuern, bevor zurückgekehrt wird. Wenn timeout nicht angegeben oder None ist, gibt es keine Wartezeitbegrenzung.

return_when gibt an, wann die Methode zurückkehren soll. Es muss eine der folgenden Konstanten sein:

Konstante	Description
FIRST_COMPLETED	Die Methode kehrt zurück, wenn irgendein Future abgeschlossen oder abgebrochen wird.
FIRST_EXCEPTION	Die Methode kehrt zurück, wenn irgendein Future eine Ausnahme auslöst. Wenn kein Future eine Ausnahme auslöst, ist sie äquivalent zu ALL_COMPLETED.
ALL_COMPLETED	Die Methode kehrt zurück, wenn alle Aufrufe abgeschlossen sind.

as_completed(fs, timeout=None)

Gibt einen Iterator über die Future-Instanzen zurück, die durch fs gegeben sind, und liefert Futures, sobald sie abgeschlossen sind (fertig oder abgebrochen). Alle Futures, die vor dem Aufruf von as_completed() abgeschlossen wurden, werden zuerst geliefert. Der zurückgegebene Iterator löst einen TimeoutError aus, wenn __next__() aufgerufen wird und das Ergebnis nicht innerhalb von timeout Sekunden nach dem ursprünglichen Aufruf von as_completed() verfügbar ist. Wenn timeout nicht angegeben oder None ist, gibt es keine Wartezeitbegrenzung.

Die Future-Instanzen können von verschiedenen Executor-Instanzen erstellt worden sein.