En tant que programmeurs, vous connaissez peut-être le concept de concurrence. La programmation simultanée est une programmation informatique qui permet à plusieurs calculs de se produire au même moment. Cela vous permet d'éviter le temps passé à attendre la fin d'une autre tâche et est donc souvent avantageux.
asyncio est une bibliothèque standard Python pour écrire du code concurrent. Il s'agit d'une conception de programmation concurrente qui facilite le fonctionnement des codes asynchrones en fournissant des méthodes pour écrire, exécuter et bien structurer vos coroutines.
Lisez la suite pour en savoir plus sur asyncio et son utilisation en détail.
Introduction
Considérez une application Web qui implique le traitement de plusieurs requêtes provenant de plusieurs utilisateurs différents dans un court laps de temps spécifié. Dans un tel cas, si le deuxième processus doit attendre la fin du premier et ainsi de suite, ce serait tout simplement inutile et une perte de temps importante.
C'est là qu'intervient la programmation concurrente en permettant à l'application de traiter plus d'une demande simultanément.
Les E/S asynchrones, comme son nom l'indique, sont un modèle d'entrée-sortie qui permet à un processus de continuer même avant la fin des autres processus/processus précédents. En termes simples, dans les E/S asynchrones, rien n'attend que quoi que ce soit (aucune opération) ne se termine.
Différents langages de programmation ont différentes bibliothèques et méthodes pour faciliter la même chose. En programmation Python, asyncio est la bibliothèque standard pour les opérations d'E/S asynchrones en utilisant la syntaxe async/wait.
Concepts importants pour la programmation asynchrone en Python
Coroutines
Les coroutines sont des fonctions de contrôle générales utilisées pour les tâches coopératives. Ils permettent de suspendre l'exécution avant d'atteindre l'instruction de retour et de passer le flux de contrôle à différentes routines.
Vous pouvez créer une coroutine en utilisant le mot-clé async avant def dans la méthode.
Créons un exemple de coroutine :
async def eg_coroutine():
for i in range(200):
print("Hello from Codespeedy!") Pour appeler ou exécuter une coroutine, vous devez d'abord la programmer sur la boucle Event. Sinon, il peut générer une erreur. Une fois planifiés, vous pouvez les envelopper dans des tâches en tant qu'objets futurs.
Tâches
Afin d'exécuter deux coroutines ou plus simultanément, il est important de les programmer dans le bon ordre. Les tâches nous permettent de faire la même chose.
Lorsque vous traitez une coroutine particulière, dans la boucle d'événements, elle renvoie un objet Task pour contrôler le comportement de cette routine.
import asyncio
async def eg_coroutine():
print('Hello!')
await asyncio.sleep(1)
print('Welcome to CodeSpeedy!')
async def main():
task = asyncio.create_task (eg_coroutine())
await task
await main() Hello! Welcome to CodeSpeedy!
Dans le code ci-dessus ;
- Nous avons utilisé create_task d'asyncio pour créer une tâche pour la coroutine.
La méthode create_task() gère les coroutines pour qu'elles s'exécutent simultanément avec d'autres tâches, en basculant entre elles en cas d'attente.
Boucles d'événements
Ce sont des mécanismes qui garantissent que les coroutines s'exécutent jusqu'à ce que leur exécution soit terminée. Il surveille l'exécution des coroutines en vérifiant quels processus sont inactifs, quels processus sont en cours d'exécution, en réveillant les routines inactives au bon moment, en évitant les attentes inutiles, etc. une seule période de temps.
Prenons un exemple où nous définissons une boucle d'événement pour exécuter 3 tâches simultanément ;
import asyncio
async def eg_coroutine(task_no):
print(f'{task_no} :Hello!')
await asyncio.sleep(1)
print(f'{task_no} :Welcome to CodeSpeedy!!')
async def main():
task1 = loop.create_task (eg_coroutine('task1'))
task2 = loop.create_task(eg_coroutine('task2'))
task3 = loop.create_task(eg_coroutine('task3'))
await asyncio.wait([task1,task2,task3])
if __name__ == "__main__":
try:
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
except :
pass task1 :Hello! task2 :Hello! task3 :Hello! task1 :Welcome to CodeSpeedy!! task2 :Welcome to CodeSpeedy!! task3 :Welcome to CodeSpeedy!!
Ici ;
- Nous avons créé 3 tâches task1, task2, task3 en utilisant create_task() et les avons ajoutées dans une liste en utilisant asyncio.wait().
- Le asyncio.get_event_loop() obtient la boucle d'événements en cours. Dans le cas où aucune boucle d'événement actuelle n'est définie dans le thread actuel du système d'exploitation, que le thread du système d'exploitation est principal et que set_event_loop() n'est pas encore appelé, asyncio créera une nouvelle boucle d'événement et la définira comme la boucle actuelle.
- La loop.run_until_complete() s'exécute jusqu'à ce qu'une instance du futur (objet coroutine) soit terminée. Ici, il s'exécute jusqu'à ce que main() soit exécuté.
- Le mot-clé attendre de la bibliothèque asyncio est utilisé pour transférer le contrôle de flux à la routine spécifiée.
asyncio en Python :un exemple de programme
import asyncio
async def eg_coroutine1():
for i in range(3):
print("Hello!")
print("Welcome to CodeSpeedy!")
await asyncio.sleep(0.01)
return 0
async def eg_coroutine2():
print("See you again!")
return 0
async def main():
f1 = loop.create_task(eg_coroutine1())
f2 = loop.create_task(eg_coroutine2())
await asyncio.wait([f1, f2])
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close() Hello! Welcome to CodeSpeedy! See you again! Hello! Welcome to CodeSpeedy! Hello! Welcome to CodeSpeedy!
Il y a toujours eu un débat sur l'efficacité des applications synchrones par rapport aux applications asynchrones. Vous pouvez observer que la programmation concurrente permet le partage des ressources, améliore la vitesse d'exécution et augmente l'évolutivité. Cependant, les applications asynchrones feront mieux que les applications de synchronisation uniquement lorsqu'il y a une charge élevée.
Vérifiez également,
Comment réaliser un traitement parallèle en Python
