Einführung in Aufgaben und Event Loop

5.1 Event Loop

Jetzt werfen wir einen kurzen Blick auf den zweiten Teil der Asynchronität, der von allen Seiten auftauchte: den Event Loop, Task und Future.

Stell dir den Event Loop wie einen Dirigenten eines Orchesters vor, Task wie die Musiker und Future wie die Noten, die die Musiker spielen sollen. Der Dirigent (Event Loop) koordiniert die Arbeit der Musiker (Task), die Musik (asynchrone Operationen) spielen, indem sie die Noten (Future) lesen.

Der Event Loop ist die Grundlage der asynchronen Programmierung in Python. Er ist zuständig für die Ausführung asynchroner Aufgaben, das Management von Events und die Ein-/Ausgabe-Verarbeitung. Der Event Loop prüft kontinuierlich auf neue Events oder Aufgaben und startet sie, sobald sie bereit sind.

Hauptfunktionen

• run_forever(): Startet den Event Loop und führt ihn aus, bis stop() aufgerufen wird.
• run_until_complete(future): Startet den Event Loop und beendet ihn nach Abschluss des angegebenen Future-Objekts oder der Coroutine.
• stop(): Stoppt den Event Loop.
• create_task(coroutine): Plant die Ausführung einer Coroutine als Aufgabe.

Verwendungsbeispiel:

import asyncio

async def hello():
    print("Hello, world!")
    await asyncio.sleep(1)
    print("Hello again!")
            
loop = asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()

In diesem Beispiel verwenden wir zunächst die Methode get_event_loop(), um das aktuelle EventLoop-Objekt der asyncio-Bibliothek zu erhalten.

Dann fügen wir diesem EventLoop die Coroutine hello hinzu und bitten ihn, sie mit der Methode run_until_complete() auszuführen.

Im letzten Schritt schließen wir das EventLoop mit der Methode close().

Wenn du diesen Code ausführst, wirst du sehen, dass zuerst "Hello, world!" ausgegeben wird, dann wartet das Programm 1 Sekunde und anschließend wird "Hello again!" ausgegeben. Dies zeigt, wie der Event Loop die Ausführung der asynchronen Funktion steuert.

Diese Aktionen werden wir in der nächsten Vorlesung ausführlicher betrachten.

5.2 Tasks

Aufgaben (Tasks) sind eine Umhüllung für Coroutinen, die es ermöglicht, ihre Ausführung zu verwalten und ihren Status zu verfolgen. Tasks erlauben es, Coroutinen parallel auszuführen, indem sie über den Event Loop verwaltet werden.

Erstellung und Verwaltung von Tasks

• asyncio.create_task(coroutine): Erstellt eine Aufgabe zur Ausführung der Coroutine.
• Task.result(): Gibt das Ergebnis einer abgeschlossenen Aufgabe zurück oder löst eine Ausnahme aus, wenn die Aufgabe mit einem Fehler beendet wurde.
• Task.cancel(): Stoppt die Ausführung der Aufgabe.

Verwendungsbeispiel:

import asyncio

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

In diesem Beispiel umhüllen wir die Coroutine say_hello() mit einem Task-Objekt. Es ist ebenfalls ein asynchrones Objekt, daher muss man den await-Operator verwenden, um das Ergebnis zu erhalten.

Bei der Ausführung dieses Codes wartet das Programm 1 Sekunde und gibt dann "Hello" aus. Dies zeigt, wie Task die Ausführung der Coroutine verwaltet und wie wir auf deren Abschluss mit await warten können.

Detailliertere Informationen zur Arbeit mit Tasks Task werden in der nächsten Vorlesung behandelt.

5.3 Futures

Future-Objekte stellen das Ergebnis einer asynchronen Operation dar, das in der Zukunft verfügbar sein wird. Sie ermöglichen das Management des Status einer asynchronen Operation, indem sie das Ergebnis oder eine Ausnahme festlegen.

Wichtige Methoden:

• set_result(result): Legt das Ergebnis für das Future-Objekt fest.
• set_exception(exception): Legt eine Ausnahme für das Future-Objekt fest.
• result(): Gibt das Ergebnis des Future-Objekts zurück oder löst eine Ausnahme aus, wenn die Operation mit einem Fehler beendet wurde.
• exception(): Gibt eine Ausnahme zurück, wenn eine solche festgelegt wurde.

Verwendungsbeispiel:

import asyncio

async def set_future(fut, value):
    await asyncio.sleep(1)
    fut.set_result(value)
            
async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()
    await set_future(fut, 'Hello, future!')
    print(fut.result())
            
asyncio.run(main())

In diesem Beispiel erstellen wir ein Future, legen seinen Wert nach einer Sekunde fest und geben dann das Ergebnis aus. Du wirst sehen, dass das Programm eine Sekunde wartet, bevor es 'Hello, future!' ausgibt. Dies zeigt, wie Future ein Ergebnis darstellt, das in der Zukunft verfügbar wird.

Im Gegensatz zu einem Task-Objekt ist ein Future-Objekt an ein bestimmtes Event Loop gebunden, und die ausgeführte asynchrone Funktion kann ihr Ergebnis darin speichern. Obwohl dies normalerweise etwas anders funktioniert.

Meistens werden Future-Objekte in Verbindung mit Task-Aufgaben verwendet, die eine höherstufige Steuerung von asynchronen Operationen bieten.

Jetzt, nachdem du den Event Loop, Task und Future kennengelernt hast, werden wir sie ausführlicher betrachten.