La programmation asynchrone est un paradigme de programmation qui permet à de nombreux processus de s'exécuter simultanément et indépendamment, sans attendre la fin de l'un avant de passer au suivant. Dans cet article de blog, nous verrons ce qu'est la programmation asynchrone et comment l'utiliser en python.

Qu'est-ce que la programmation asynchrone ?

En programmation synchrone, l'ordinateur exécute les instructions dans un ordre séquentiel, bloquant l'exécution jusqu'à ce qu'une tâche soit terminée avant de passer à la suivante.
La programmation asynchrone, quant à elle, permet au programme de commencer une opération, puis de passer à une autre sans arrêter l'exécution jusqu'à ce que la tâche d'origine soit terminée.

La programmation asynchrone est particulièrement bénéfique dans les circonstances où les processus, tels que les opérations d'E/S réseau ou de base de données, peuvent prendre beaucoup de temps. La programmation asynchrone peut aider à augmenter les performances et la réactivité des applications logicielles en permettant au programme de poursuivre d'autres activités en attendant la fin d'une opération lente.

Selon le langage de programmation et le framework utilisés, la programmation asynchrone peut être réalisée à l'aide de diverses stratégies telles que les rappels, les promesses ou les mots-clés async/wait.

Différences entre la programmation asynchrone et le multitraitement

La principale différence entre la programmation asynchrone et le multitraitement est que la programmation asynchrone permet à des opérations non bloquantes de se produire dans un seul thread, tandis que le multitraitement utilise plusieurs cœurs ou processus pour effectuer le travail simultanément.

Différences entre la programmation asynchrone et le threading

La principale différence entre la programmation asynchrone et le threading est que la programmation asynchrone permet des opérations non bloquantes en utilisant un seul thread, tandis que le threading utilise plusieurs threads pour effectuer plusieurs tâches en parallèle.

Pour plus d'informations sur les différences : pas à pas vs multitraitement vs programmation asynchrone

Comment utiliser Asyncio ?

Commençons par créer un programme simple qui commence à faire un travail à la fois et les termine.

import time
import asyncio

def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

main()

# OUTPUT
# Job A started
# Job Adone
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

Création et exécution de coroutines

Une coroutine est un type de fonction qui peut être interrompue et reprise à différents moments de l'exécution. En d'autres termes, une coroutine vous permet d'écrire du code qui peut être interrompu, de faire autre chose, puis de reprendre là où il s'était arrêté.

Pour créer des coroutines, nous devons utiliser le asyncmot-clé avant le defmot-clé. L'appel d'une coroutine n'appelle pas la fonction que nous voulons exécuter. Il crée une tâche.

import time
import asyncio

async def do_job(s):
  ...

async def main():
  ...

main()

asyncio.run(main())

si vous exécutez ce code, vous obtenez probablement une erreur comme celle-ci :

RuntimeWarning: coroutine '...' was never awaited

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    for job in todo:
        await do_job(job)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job A done
# Job B started
# Job B done
# Job C started
# Job C done
# Took: 3.009 seconds

await asyncio.sleep(1)

tasks = [asyncio.create_task(do_job(item)) for item in todo]
done, pending = await asyncio.wait(tasks)

import time
import asyncio

async def do_job(s):
    print(f"{s} started")
    await asyncio.sleep(1)
    print(f"{s} done")

async def main():
    start = time.perf_counter()
    todo = ["Job A", "Job B", "Job C"]
    
    tasks = [asyncio.create_task(do_job(item)) for item in todo]
    done, pending = await asyncio.wait(tasks)
    
    end = time.perf_counter()
    print(f"Took: {end-start:.3f} seconds")

asyncio.run(main())

# OUTPUT
# Job A started
# Job B started
# Job C started
# Job A done
# Job B done
# Job C done
# Took: 1.009 seconds

Vous pouvez voir la vidéo pour obtenir plus d'informations sur la programmation asynchrone en python. ( Introduction à Python asynchrone | Écrire un robot d'exploration Web )