Classe Future

8.1 Caractéristiques principales de la classe Future

La classe Future dans le module asyncio représente le résultat d'une opération asynchrone qui sera disponible dans le futur. Les objets Future sont utilisés pour gérer l'état et les résultats des tâches asynchrones.

Caractéristiques principales de la classe Future

Un objet Future est un conteneur pour le résultat qui sera disponible plus tard, lorsque la tâche sera terminée. Il fournit une interface pour obtenir le résultat ou l'exception qui sera fixé après la fin de l'opération asynchrone.

Création et gestion des objets Future

• Création : Habituellement créé en utilisant loop.create_future().
• Fixer le résultat : Le résultat est fixé à l'aide de la méthode set_result(result).
• Fixer l'exception: L'exception est fixée à l'aide de la méthode set_exception(exception).

Méthodes et attributs principaux

set_result(result):

Fixe le résultat pour l'objet Future. Toutes les coroutines qui attendent cet objet seront immédiatement reprises avec ce résultat.

set_exception(exception):

Fixe l'exception pour l'objet Future. Toutes les coroutines qui attendent cet objet seront immédiatement reprises avec cette exception.

result():

Renvoie le résultat de l'objet Future, s'il est disponible. Si l'opération s'est terminée avec une exception, elle lancera cette exception.

exception():

Renvoie l'exception si elle a été fixée, ou None si l'objet Future n'est pas encore terminé ou s'est terminé avec succès.

done():

Renvoie True si l'objet Future est terminé (avec un résultat ou une exception).

add_done_callback(callback):

Ajoute un rappel qui sera appelé à la fin de l'objet Future.

8.2 Exemples d'utilisation

Fixer et obtenir le résultat

import asyncio

async def set_future_result(fut, delay):
    await asyncio.sleep(delay)
    fut.set_result("Le résultat du Future est prêt")
            
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())

Gestion des exceptions

import asyncio

async def set_future_exception(fut, delay):
    await asyncio.sleep(delay)
    fut.set_exception(ValueError("Une erreur s'est produite"))
            
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"Exception capturée : {e}")

asyncio.run(main())

Interaction avec les tâches

Les objets Future sont souvent utilisés en conjonction avec des tâches (Tasks). Quand une tâche est créée avec asyncio.create_task(), elle crée automatiquement un objet Future qui peut être utilisé pour suivre et gérer l'état de la tâche.

import asyncio

async def example_coroutine():
    await asyncio.sleep(1)
    return "Résultat de la tâche"
            
async def main():
    task = asyncio.create_task(example_coroutine())
    print(await task)
            
asyncio.run(main())

8.3 Avantages et caractéristiques

Les objets Future permettent de gérer les résultats et les exceptions des opérations asynchrones, offrant flexibilité et contrôle sur l'exécution. Future peut être utilisé dans divers scénarios de programmation asynchrone, y compris les tâches, les temporisateurs, les rappels et bien plus encore.

Souvent, les objets Future sont utilisés en conjonction avec des tâches (Tasks). Cette approche permet un niveau de contrôle plus élevé sur l'exécution et l'état des opérations asynchrones.

Limitations

Dans certains cas, l'utilisation de Future peut être plus complexe par rapport à l'utilisation d'abstractions de plus haut niveau, telles que les tâches (Tasks) ou les coroutines. Avec Future, il peut être nécessaire de gérer plus manuellement l'état et les résultats des opérations asynchrones.