Event Loop

6.1 Erhalten der Ereignisschleife

Die Ereignisschleife (Event Loop) ist eine zentrale Komponente der asynchronen Programmierung mit dem asyncio-Modul in Python. Sie verwaltet die Ausführung asynchroner Aufgaben, die Verarbeitung von Ereignissen und die Ausführung von Ein-/Ausgabeoperationen. Die Ereignisschleife erlaubt es, mehrere Aufgaben gleichzeitig auszuführen, ohne den Hauptausführungsfluss zu blockieren.

Erstellen und Erhalten der Ereignisschleife

• asyncio.get_event_loop(): Gibt die aktuelle Ereignisschleife zurück oder erstellt eine neue, wenn keine vorhanden ist.
• asyncio.new_event_loop(): Erstellt eine neue Ereignisschleife.
• asyncio.set_event_loop(loop): Setzt die angegebene Ereignisschleife als die aktuelle.

Beispiel:

Asyncio hat eine aktuelle Ereignisschleife, die alle auszuführenden Aufgaben enthält. Du kannst die aktuelle Ereignisschleife erhalten oder eine neue erstellen und sie als aktuell setzen. Das wird im Beispiel unten gezeigt.

import asyncio

loop = asyncio.get_event_loop()
print(loop)  # Aktuelle Ereignisschleife
new_loop = asyncio.new_event_loop()
asyncio.set_event_loop(new_loop)
print(asyncio.get_event_loop())  # Neue gesetzte Ereignisschleife

Es ist zu beachten, dass die Methode get_event_loop() die aktuell aktive Ereignisschleife zurückgibt. Die Erstellung einer neuen Ereignisschleife und deren Setzen sollten mit Vorsicht verwendet werden, um Konflikte in asynchronen Anwendungen zu vermeiden.

Starten der Ereignisschleife

• run_forever(): Startet die Ereignisschleife und hält sie am Laufen, bis stop() aufgerufen wird.
• run_until_complete(future): Startet die Ereignisschleife und beendet sie, nachdem die angegebene Coroutine oder das Future-Objekt abgeschlossen ist.

Beispiel:

Die Ereignisschleife kann in zwei Modi gestartet werden: sie läuft für immer – so etwas wie while True, oder bis eine bestimmte Aufgabe abgeschlossen ist.

import asyncio

async def hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")
            
loop = asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()

Wenn du die Event Loop im run_forever()-Modus gestartet hast, wird sie sich endlos in sich selbst drehen. Die Methode run_forever() beendet die Arbeit nur, wenn eine asynchrone Aufgabe in unserer EventLoop die Methode stop() aufruft.

Anhalten der Ereignisschleife

• stop(): Hält die Ereignisschleife an.
• is_running(): Gibt True zurück, wenn die Ereignisschleife läuft.

Beispiel:

Wenn die Schleife im unendlichen Modus ausgeführt wird, nimmt sie ständig Aufgaben entgegen und führt sie aus, sie wird sich nicht von selbst anhalten. Jemand muss das Objekt unserer aktuellen Schleife erhalten und die Methode stop() aufrufen. Um herauszufinden, ob die Schleife ewig läuft oder nicht, muss die Methode is_running() aufgerufen werden.

import asyncio
            
loop = asyncio.get_event_loop()
loop.stop()
print(loop.is_running())  # Falsch

6.2 Wichtige Methoden der Ereignisschleife

Methode call_soon(callback, *args)

Plant den Aufruf der Funktion callback mit den Argumenten *args so schnell wie möglich.

import asyncio

def my_callback():
    print("Callback executed")
            
loop = asyncio.get_event_loop()
loop.call_soon(my_callback)
loop.run_forever()

Platziert die Funktion callback an den Anfang der Aufgabenliste, damit sie so schnell wie möglich ausgeführt wird. Du kannst nicht-asynchrone Funktionen in die Methode übergeben. Diese Methode ist nützlich, wenn eine Aufgabe mit minimaler Verzögerung ausgeführt werden muss, insbesondere wenn eine sofortige Rückmeldung in einer asynchronen Anwendung erforderlich ist.

Methode call_later(delay, callback, *args)

Plant den Aufruf der Funktion callback mit den Argumenten *args nach delay Sekunden.

import asyncio

def my_callback():
    print("Callback executed after delay")
            
loop = asyncio.get_event_loop()
loop.call_later(2, my_callback)
loop.run_forever()

Diese Methode ermöglicht einen verzögerten Funktionsaufruf: das erste Argument ist die Verzögerung in Sekunden (kann gebrochen sein), der Rest ist ein Verweis auf die Funktion und deren Parameter. Du kannst nicht-asynchrone Funktionen in die Methode übergeben. Diese Methode kann verwendet werden, um die Ausführung von Aufgaben mit unterschiedlichen Dringlichkeitsstufen zu steuern, was bei der Gestaltung komplexer asynchroner Systeme nützlich ist.

Methode call_at(when, callback, *args)

Plant den Aufruf der Funktion callback mit den Argumenten *args zum Zeitpunkt when.

import asyncio
import time
            
def my_callback():
    print("Callback executed at specific time")
            
loop = asyncio.get_event_loop()
when = loop.time() + 2  # In 2 Sekunden ab der aktuellen Zeit der Ereignisschleife
loop.call_at(when, my_callback)
loop.run_forever()

Wenn du eine Aufgabe nicht in 5 Sekunden, sondern beispielsweise um 15:00 oder 24:00 Uhr starten möchtest, dann ist es bequemer, die Funktion call_at() zu verwenden, die genauso funktioniert wie die Funktion call_soon(), aber als erstes Argument wird nicht die Pausenlänge, sondern die Zeit übergeben, zu der die bestimmte Funktion aufgerufen werden soll. Du kannst nicht-asynchrone Funktionen in die Methode übergeben.

Vorteile und Eigenschaften

Asynchrone Ausführung: Die Ereignisschleife ermöglicht es, viele Aufgaben parallel auszuführen, ohne den Hauptausführungsfluss zu blockieren.

Effizientes Ressourcenmanagement: Asynchrone Ein-/Ausgabeoperationen werden ohne Blockierung ausgeführt, wodurch Programme effizienter werden.

Flexibilität und Skalierbarkeit: Die Ereignisschleife unterstützt viele Methoden zur Aufgabenplanung und Ereignisverarbeitung, was die Erstellung komplexer und skalierbarer asynchroner Anwendungen ermöglicht.

6.3 Interaktion mit Aufgaben und Future-Objekten

Die Ereignisschleife verwaltet die Ausführung von Aufgaben (Tasks) und Future-Objekten (Futures). Sie überwacht deren Zustand und sorgt für deren Ausführung nach Bereitschaft.

Beispiel:

import asyncio

async def main():
    await asyncio.sleep(1)
    print("Task completed")
            
loop = asyncio.get_event_loop()
task = loop.create_task(main())
loop.run_until_complete(task)

In diesem Beispiel wird gezeigt, wie die Ereignisschleife die Ausführung einer Aufgabe verwaltet, die mit der Methode create_task erstellt wurde. Die Methoden call_soon(), call_later() und call_at() können verwendet werden, um die Ausführung von Aufgaben mit unterschiedlichen Dringlichkeitsstufen zu steuern, was bei der Gestaltung komplexer asynchroner Systeme nützlich ist.