Clase Future

8.1 Características principales de la clase Future

La clase Future en el módulo asyncio representa el resultado de una operación asíncrona que estará disponible en el futuro. Los objetos Future se utilizan para gestionar el estado y los resultados de las tareas asíncronas.

Características principales de la clase Future

Un objeto Future es un contenedor para el resultado que estará disponible más tarde, cuando la tarea termine de ejecutarse. Proporciona una interfaz para obtener el resultado o la excepción, que serán establecidos tras completar la operación asíncrona.

Creación y gestión de objetos Future

• Creación: Normalmente se crea usando loop.create_future().
• Establecer resultado: El resultado se establece mediante el método set_result(result).
• Establecer excepción: La excepción se establece mediante el método set_exception(exception).

Métodos y atributos principales

set_result(result):

Establece el resultado para el objeto Future. Todas las corutinas que esperen este objeto se reanudarán inmediatamente con este resultado.

set_exception(exception):

Establece una excepción para el objeto Future. Todas las corutinas que esperen este objeto se reanudarán inmediatamente con esta excepción.

result():

Devuelve el resultado del objeto Future, si está disponible. Si la operación finalizó con una excepción, lanzará esa excepción.

exception():

Devuelve la excepción, si fue establecida, o None, si el objeto Future aún no ha terminado o terminó exitosamente.

done():

Devuelve True si el objeto Future está completado (con resultado o excepción).

add_done_callback(callback):

Agrega un callback que será llamado al completarse el objeto Future.

8.2 Ejemplos de uso

Establecer y obtener resultado

import asyncio

async def set_future_result(fut, delay):
    await asyncio.sleep(delay)
    fut.set_result("El resultado del Future está listo")
            
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())

Gestión de excepciones

import asyncio

async def set_future_exception(fut, delay):
    await asyncio.sleep(delay)
    fut.set_exception(ValueError("Ocurrió un error"))
            
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"Se atrapó una excepción: {e}")

asyncio.run(main())

Interacción con tareas

A menudo los objetos Future se utilizan junto con las tareas (Tasks). Cuando se crea una tarea con asyncio.create_task(), automáticamente se crea un objeto Future, que puede ser utilizado para rastrear y gestionar el estado de la tarea.

import asyncio

async def example_coroutine():
    await asyncio.sleep(1)
    return "Resultado de la tarea"
            
async def main():
    task = asyncio.create_task(example_coroutine())
    print(await task)
            
asyncio.run(main())

8.3 Ventajas y características

Los objetos Future permiten gestionar los resultados y las excepciones de operaciones asíncronas, proporcionando flexibilidad y control sobre la ejecución. Future puede usarse en varios escenarios de programación asíncrona, incluyendo tareas, temporizadores, callbacks y mucho más.

A menudo los objetos Future se utilizan junto con las tareas (Tasks). Este enfoque permite obtener un mayor nivel de control sobre la ejecución y el estado de las operaciones asíncronas.

Limitaciones

En algunos casos, el uso de Future puede ser más complejo en comparación con el uso de abstracciones de nivel superior, como las tareas (Tasks) o las corutinas. Al usar Future puede requerirse más gestión manual del estado y los resultados de las operaciones asíncronas.