Découverte des tâches et de la boucle d'événements

5.1 Boucle d'événements

Maintenant, abordons brièvement la deuxième partie de l'asynchrone, qui surgit de toutes parts : la boucle d'événements (Event Loop), les tâches (Task) et Future.

Imagine Event Loop comme un chef d'orchestre, Task comme les musiciens, et Future comme les partitions que les musiciens doivent jouer. Le chef d'orchestre (Event Loop) coordonne le travail des musiciens (Task), qui exécutent la musique (opérations asynchrones) en lisant les partitions (Future).

La boucle d'événements (Event Loop) est la base de la programmation asynchrone en Python. Elle est responsable de l'exécution des tâches asynchrones, de la gestion des événements et du traitement des entrées-sorties. La boucle d'événements vérifie en continu la présence de nouveaux événements ou tâches et les lance lorsqu'ils sont prêts.

Fonctions principales

• run_forever(): Démarre la boucle d'événements et la maintient en fonctionnement jusqu'à l'appel de stop().
• run_until_complete(future): Démarre la boucle d'événements et la termine après la complétion de l'objet futur ou coroutine spécifié.
• stop(): Arrête la boucle d'événements.
• create_task(coroutine): Planifie l'exécution d'une coroutine comme une tâche.

Exemple d'utilisation :

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()

Dans cet exemple, nous utilisons d'abord la méthode get_event_loop() pour obtenir l'objet EventLoop actuel de la bibliothèque asyncio.

Ensuite, nous ajoutons à cet EventLoop la coroutine hello et lui demandons de l'exécuter via la méthode run_until_complete().

Au dernier pas, nous fermons l'EventLoop avec la méthode close().

En exécutant ce code, tu verras d'abord "Hello, world!" s'afficher, ensuite le programme attendra 1 seconde, et après cela, "Hello again!" s'affichera. Cela démontre comment Event Loop gère l'exécution d'une fonction asynchrone.

Nous examinerons ces actions plus en détail dans la prochaine leçon.

5.2 Tasks

Les tâches (Tasks) sont comme des envoloppes pour les coroutines, permettant de gérer leur exécution et de suivre leur état. Les tâches permettent d'exécuter des coroutines en parallèle, les gérant via la boucle d'événements.

Création et gestion des tâches

• asyncio.create_task(coroutine): Crée une tâche pour exécuter une coroutine.
• Task.result(): Retourne le résultat d'une tâche terminée ou lève une exception si la tâche s'est terminée avec une erreur.
• Task.cancel(): Annule l'exécution d'une tâche.

Exemple d'utilisation :

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())

Dans cet exemple, nous enveloppons la coroutine say_hello() dans un objet Task. Celui-ci est également un objet asynchrone, donc pour obtenir son résultat, il faut utiliser l'opérateur await.

En exécutant ce code, le programme attendra 1 seconde, puis affichera "Hello". Cela montre comment la tâche gère l'exécution d'une coroutine et comment attendre sa complétion avec await.

Plus de détails sur le travail avec les tâches Task seront abordés dans la prochaine leçon.

5.3 Futures

Les objets Future représentent le résultat d'une opération asynchrone, qui sera disponible dans le futur. Ils permettent de gérer l'état d'une opération asynchrone, en réglant le résultat ou l'exception.

Méthodes principales:

• set_result(result): Définit le résultat pour l'objet Future.
• set_exception(exception): Définit l'exception pour l'objet Future.
• result(): Retourne le résultat de l'objet Future ou lève une exception si l'opération s'est terminée avec une erreur.
• exception(): Retourne l'exception si elle a été définie.

Exemple d'utilisation :

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())

Dans cet exemple, nous créons un Future, définissons sa valeur après une seconde, puis affichons le résultat. Tu verras que le programme attendra une seconde avant d'afficher 'Hello, future!'. Cela démontre comment Future représente un résultat qui sera disponible dans le futur.

Contrairement à l'objet Task, l'objet Future est lié à une Event Loop spécifique, et la fonction asynchrone exécutée peut y enregistrer son résultat. Bien que normalement cela fonctionne un peu différemment.

Le plus souvent, les objets Future sont utilisés en combinaison avec les tâches Task, qui fournissent une gestion de plus haut niveau des opérations asynchrones.

Maintenant que tu connais Event Loop, Task et Future, nous allons les examiner plus en détail.