Comment créer et exécuter des tâches asynchrones en Python

1. Qu'est-ce qu'une tâche asynchrone

Une tâche asynchrone est un objet qui planifie et exécute une coroutine asyncio de manière indépendante. Il fournit un handle pour la coroutine distribuée que les programmes asyncio peuvent interroger et utiliser pour interagir avec la coroutine.

Les tâches sont créées à partir de coroutines. Il prend un objet coroutine, encapsule la coroutine, planifie son exécution et fournit des méthodes pour interagir avec lui. Les tâches sont exécutées indépendamment. Cela signifie qu'il est planifié dans la boucle d'événements asyncio et s'exécutera indépendamment de ce qui se passe dans la coroutine qui l'a créé. Ceci est différent de l’exécution directe de la coroutine, où l’appelant doit attendre qu’elle se termine.

La classe asyncio.Task étend la classe asyncio.Future, une instance est attendue. Future est une classe de niveau inférieur qui représente le résultat qui finira par arriver. Les classes qui étendent la classe Future sont souvent appelées Future-like.

Étant donné que les tâches asynchrones sont attendues, cela signifie que les coroutines peuvent utiliser des expressions d'attente pour attendre la fin de la tâche.

...
# wait for a task to be done
await task

Maintenant que nous savons ce qu'est une tâche asyncio, voyons comment en créer une.

2. Comment créer une tâche

Créez une tâche à l'aide de l'instance de coroutine fournie. Rappelez-vous qu'une coroutine est définie à l'aide d'une expression def asynchrone et ressemble à une fonction.

# define a coroutine
async def task_coroutine():
	# ...

Les tâches ne peuvent être créées et planifiées que dans des coroutines. Il existe deux manières principales de créer et de planifier des tâches :

• Utiliser une API de haut niveau pour créer des tâches (de préférence)

• Utiliser une API de bas niveau pour créer des tâches

2.1. API

Vous pouvez utiliser la fonction asyncio.create_task() pour créer la tâche. La fonction asyncio.create_task() accepte une instance de coroutine et un nom de tâche facultatif, et renvoie une instance asyncio.Task.

...
# create a coroutine
coro = task_coroutine()
# create a task from a coroutine
task = asyncio.create_task(coro)

Cela peut être réalisé en utilisant des instructions composées sur une seule ligne.

...
# create a task from a coroutine
task = asyncio.create_task(task_coroutine())

Cela fera plusieurs choses :

• Enveloppez la coroutine dans une instance de tâche asynchrone.

• Planification des tâches à exécuter dans la boucle d'événements en cours.

• Renvoie une instance de tâche

Les instances de tâches peuvent être supprimées, interagies avec des méthodes et attendues par des coroutines. C'est le moyen préféré pour créer des tâches à partir de coroutines dans les programmes asyncio.

2.2. API de bas niveau

Vous pouvez également utiliser l'API asyncio de niveau inférieur pour créer des tâches à partir de coroutines.

La première méthode consiste à utiliser la fonction asyncio.ensure_future(). Cette fonction prend une tâche, un futur ou un objet de type futur tel qu'une coroutine, et éventuellement une boucle pour la planifier. Si aucune boucle n'est fournie, elle sera programmée dans la boucle d'événement en cours.

Si une coroutine est fournie pour cette fonction, elle sera enveloppée dans une instance pour nous puis renvoyée.

...
# create and schedule the task
task = asyncio.ensure_future(task_coroutine())

Une autre fonction de bas niveau que nous pouvons utiliser pour créer et planifier des tâches est la méthode loop.create_task(). Cette fonction nécessite l'accès à une boucle d'événements spécifique où la coroutine est exécutée en tant que tâche.

Nous pouvons obtenir l'instance de boucle d'événement actuelle dans le programme asyncio via la fonction asyncio.get_event_loop(). Cela peut ensuite être utilisé pour appeler la méthode create_task() pour créer une instance de tâche et planifier son exécution.

...
# get the current event loop
loop = asyncio.get_event_loop()
# create and schedule the task
task = loop.create_task(task_coroutine())

3. Quand la tâche sera-t-elle exécutée ?

Une question courante après la création d'une tâche est de savoir quand sera-t-elle exécutée ?

Bien que nous puissions planifier l'exécution de la coroutine indépendamment en tant que tâche via la fonction create_task(), elle peut ne pas s'exécuter immédiatement. En fait, la tâche ne s'exécutera pas tant que la boucle d'événements n'aura pas la possibilité de s'exécuter.

Cela n'arrivera pas tant que toutes les autres coroutines ne seront pas exécutées et que ce sera au tour de la tâche de s'exécuter.

Par exemple, si nous avons un programme asyncio avec une coroutine qui crée et planifie des tâches, les tâches planifiées ne s'exécuteront pas tant que la coroutine appelante qui a créé la tâche n'est pas suspendue.

Cela peut se produire si la coroutine appelante choisit de dormir, choisit d'attendre une autre coroutine ou une autre tâche, ou choisit d'attendre une nouvelle tâche qui a été planifiée.

...
# create a task from a coroutine
task = asyncio.create_task(task_coroutine())
# await the task, allowing it to run
await task

Maintenant, nous savons ce que sont les tâches et comment les planifier.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!