Creazione ed Esecuzione di Coroutine

Per iniziare a lavorare con la programmazione asincrona in Python, è necessario comprendere le coroutine. Una coroutine è una funzione speciale definita con async def. Le coroutine permettono di sospendere e riprendere l'esecuzione, rendendo possibile gestire attività come l'attesa di operazioni di input/output - ad esempio lettura di file, richieste di rete o interrogazioni al database - senza bloccare l'intero programma. Questo significa che mentre un'attività è in attesa di dati, altre attività possono continuare a essere eseguite, migliorando l'efficienza e la reattività.

Per eseguire una coroutine, si utilizza asyncio.run, che avvia un event loop, esegue la coroutine e chiude il loop al termine. Questo è il metodo standard per avviare codice asincrono nel Python moderno.

Supponiamo di voler eseguire più di una coroutine contemporaneamente. È possibile utilizzare asyncio.gather per pianificarle in modo concorrente. Questo consente al programma di avviare più attività e attendere che tutte siano completate, sfruttando meglio il tempo soprattutto durante operazioni lente come l'I/O.

Il seguente codice dimostra questi concetti.

import asyncio

async def greet(name, delay):
    await asyncio.sleep(delay)
    print(f"Hello, {name}!")

async def main():
    # Schedule two coroutines to run concurrently
    await asyncio.gather(
        greet("Alice", 2),
        greet("Bob", 1)
    )

asyncio.run(main())

Risultato atteso:

Hello, Bob!
Hello, Alice!

Il saluto di Bob appare per primo perché utilizza un ritardo più breve (1 secondo) rispetto a quello di Alice (2 secondi).

La coroutine greet viene creata con async def, permettendo di sospendere l'esecuzione con await asyncio.sleep(delay) prima di stampare un saluto. La coroutine main pianifica due istanze di greet - una per "Alice" con un ritardo di 2 secondi e una per "Bob" con un ritardo di 1 secondo - utilizzando asyncio.gather. Questo significa che entrambi i saluti vengono gestiti in modo concorrente, quindi il programma non aspetta che uno finisca prima di iniziare l'altro. Infine, asyncio.run(main()) avvia il ciclo degli eventi, esegue la coroutine main e garantisce che tutto venga ripulito successivamente. Questo approccio consente di gestire più attività che comportano attese (come richieste di rete o ritardi temporali) contemporaneamente, rendendo il programma più efficiente e reattivo.