Klasse Task

7.1 Erstellen von Aufgaben

Die Klasse Task im Modul asyncio wird verwendet, um die Ausführung von Coroutinen zu verwalten. Aufgaben (Tasks) sind Wrapper für Coroutinen, die es ermöglichen, deren Ausführung zu steuern und ihren Status zu überwachen. Die Klasse Task ermöglicht es, Coroutinen parallel auszuführen und sie über den Ereignisloop zu steuern.

Hauptmethoden der Klasse Task

Die Klasse Task ist ein gewisser Wrapper um eine Coroutine, der folgende zusätzliche Funktionen bietet:

Verwaltung der Ausführung von Coroutinen:

Aufgaben ermöglichen eine einfache Verwaltung der Ausführung von Coroutinen, Kontrolle ihres Status und Erhalt der Ergebnisse.

Abbrechen von Aufgaben:

Die Möglichkeit, Aufgaben abzubrechen, macht Task nützlich für die Verwaltung von langwierigen Operationen, die möglicherweise vor Abschluss gestoppt werden müssen.

Callbacks:

Aufgaben unterstützen das Hinzufügen von Callbacks, was es ermöglicht, zusätzliche Aktionen auszuführen, wenn Aufgaben abgeschlossen sind.

Erstellen von Aufgaben:

Aufgaben werden mit der Funktion asyncio.create_task(coroutine) oder der Methode loop.create_task(coroutine) erstellt, die die Ausführung der Coroutine planen.

import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")
            
async def main():
    task = asyncio.create_task(say_hello())
    await task
            
asyncio.run(main())

7.2 Hauptmethoden

Methode Task.cancel():

Fordert das Abbrechen der Aufgabe an. Wenn die Aufgabe noch nicht abgeschlossen ist, wird sie mit dem Auslösen der Ausnahme CancelledError beendet.

Lass uns ein kleines Programm schreiben, das uns dies demonstriert.

1. Wir erstellen eine asynchrone Aufgabe, die einfach 10 Sekunden wartet
2. Wir packen sie in ein Task-Objekt
3. Wir warten eine Sekunde, damit die Aufgabe (Task) mit der Ausführung beginnt
4. Wir brechen die Aufgabe ab – task.cancel()
5. Wenn wir dann versuchen, auf den Abschluss der Aufgabe (Task) mit dem Operator await zu warten, erhalten wir die Ausnahme CancelledError.

import asyncio

async def main():
    task = asyncio.create_task(asyncio.sleep(10)) 
    await asyncio.sleep(1)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("Die Aufgabe wurde abgebrochen")
            
asyncio.run(main())

Methode Task.result():

Liefert das Ergebnis der Ausführung der Aufgabe. Wenn die Aufgabe mit einer Ausnahme abgeschlossen wurde, wird diese bei Aufruf von result() ausgelöst.

import asyncio

async def main():
    task = asyncio.create_task(asyncio.sleep(1, result='Completed'))
    result = await task
    print(result)  # Output: Completed
            
asyncio.run(main())

In unserem Fall mussten wir nicht einmal zusätzlichen Code schreiben — der Operator await versteht, wie man mit einem Task-Objekt arbeitet: Nach Abschluss der Aufgabe ruft er selbst die Methode result() auf und gibt das erhaltene Ergebnis zurück.

Methode Task.exception():

Gibt die durch die Aufgabe ausgelöste Ausnahme zurück. Wenn die Aufgabe ohne Ausnahme abgeschlossen wurde, wird None zurückgegeben.

import asyncio

async def main():
    task = asyncio.create_task(asyncio.sleep(1))
    try:
        result = await task
    except Exception as e:
        print(f"Die Aufgabe ist mit einer Ausnahme fehlgeschlagen: {e}")

asyncio.run(main())

Auch hier muss kein zusätzlicher Code geschrieben werden — wenn in der Aufgabe eine Ausnahme auftritt, wird die Methode exception() durch den Operator await aufgerufen.

Methode Task.add_done_callback(callback):

Fügt einen Callback (callback) hinzu, der beim Abschluss der Aufgabe aufgerufen wird.

import asyncio

def callback(future):
    print("Die Aufgabe wurde abgeschlossen")
            
async def main():
    task = asyncio.create_task(asyncio.sleep(1))
    task.add_done_callback(callback)
    await task
            
asyncio.run(main())

Du kannst der Aufgabe eine Funktion hinzufügen, die automatisch aufgerufen wird, wenn die Aufgabe abgeschlossen ist. Dieser Ansatz macht den Code sehr flexibel. Darüber hinaus können mehrere Funktionen hinzugefügt werden, und sie können zu beliebigen Aufgaben hinzugefügt werden.

Methode Task.done():

Gibt True zurück, wenn die Aufgabe abgeschlossen ist (erfolgreich, mit Fehler oder wurde abgebrochen).

import asyncio

async def main():
    task = asyncio.create_task(asyncio.sleep(1))
    await asyncio.sleep(1.5)
    print(task.done())  # Output: True
            
asyncio.run(main())

Mit der Methode done() kannst du herausfinden, ob die Aufgabe erfolgreich abgeschlossen wurde. Genauer gesagt, ob sie abgeschlossen oder abgebrochen wurde, denn wenn eine Ausnahme auftritt, kann die Aufgabe formal als nicht abgeschlossen gelten, aber sie wurde nicht abgebrochen. Wenn die Aufgabe abgebrochen wurde (cancel), wird die Methode False zurückgeben, andernfalls gibt sie True zurück.