Klasse Future

8.1 Hauptmerkmale der Klasse Future

Die Klasse Future im Modul asyncio stellt das Ergebnis einer asynchronen Operation dar, das in der Zukunft verfügbar sein wird. Future-Objekte werden verwendet, um den Zustand und die Ergebnisse von asynchronen Aufgaben zu verwalten.

Hauptmerkmale der Klasse Future

Ein Future-Objekt ist ein Container für das Ergebnis, das verfügbar sein wird, sobald die Aufgabe abgeschlossen ist. Es bietet eine Schnittstelle zum Abrufen des Ergebnisses oder der Ausnahme, die nach Abschluss der asynchronen Operation festgelegt wird.

Erstellen und Verwalten von Future-Objekten

• Erstellen: Wird normalerweise mit loop.create_future() erstellt.
• Ergebnis setzen: Das Ergebnis wird mit der Methode set_result(result) festgelegt.
• Ausnahme setzen: Eine Ausnahme wird mit der Methode set_exception(exception) festgelegt.

Wichtige Methoden und Attribute

set_result(result):

Setzt das Ergebnis für das Future-Objekt. Alle Coroutinen, die auf dieses Objekt warten, werden sofort mit diesem Ergebnis fortgesetzt.

set_exception(exception):

Setzt eine Ausnahme für das Future-Objekt. Alle Coroutinen, die auf dieses Objekt warten, werden sofort mit dieser Ausnahme fortgesetzt.

result():

Gibt das Ergebnis des Future-Objekts zurück, wenn es verfügbar ist. Wenn die Operation mit einer Ausnahme beendet wurde, löst sie diese Ausnahme aus.

exception():

Gibt die Ausnahme zurück, wenn sie festgelegt wurde, oder None, wenn das Future-Objekt noch nicht abgeschlossen ist oder erfolgreich abgeschlossen wurde.

done():

Gibt True zurück, wenn das Future-Objekt abgeschlossen ist (mit einem Ergebnis oder einer Ausnahme).

add_done_callback(callback):

Fügt einen Callback hinzu, der beim Abschluss des Future-Objekts aufgerufen wird.

8.2 Anwendungsbeispiele

Ergebnis setzen und abrufen

import asyncio

async def set_future_result(fut, delay):
    await asyncio.sleep(delay)
    fut.set_result("Future result is ready")
            
async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()
    asyncio.create_task(set_future_result(fut, 2))
    result = await fut
    print(result)
            
asyncio.run(main())

Fehlerbehandlung

import asyncio

async def set_future_exception(fut, delay):
    await asyncio.sleep(delay)
    fut.set_exception(ValueError("An error occurred"))
            
async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()
    asyncio.create_task(set_future_exception(fut, 2))
    try:
        result = await fut
    except ValueError as e:
        print(f"Caught an exception: {e}")

asyncio.run(main())

Interaktion mit Aufgaben

Oft werden Future-Objekte zusammen mit Aufgaben (Tasks) verwendet. Wenn eine Aufgabe mit asyncio.create_task() erstellt wird, erstellt sie automatisch ein Future-Objekt, das zur Überwachung und Verwaltung des Aufgabenstatus verwendet werden kann.

import asyncio

async def example_coroutine():
    await asyncio.sleep(1)
    return "Task result"
            
async def main():
    task = asyncio.create_task(example_coroutine())
    print(await task)
            
asyncio.run(main())

8.3 Vorteile und Besonderheiten

Future-Objekte ermöglichen die Verwaltung von Ergebnissen und Ausnahmen asynchroner Operationen und bieten Flexibilität und Kontrolle über die Ausführung. Future kann in verschiedenen Szenarien des asynchronen Programmierens verwendet werden, einschließlich Aufgaben, Timer, Rückrufe und vieles mehr.

Oft werden Future-Objekte zusammen mit Aufgaben (Tasks) verwendet. Dieser Ansatz ermöglicht ein höheres Maß an Kontrolle über die Ausführung und den Zustand von asynchronen Operationen.

Einschränkungen

In einigen Fällen kann die Verwendung von Future komplexer sein als die Verwendung von höherstufigen Abstraktionen wie Aufgaben (Tasks) oder Coroutinen. Bei der Verwendung von Future kann mehr manuelles Management des Zustands und der Ergebnisse asynchroner Operationen erforderlich sein.