Classe Future

8.1 Caratteristiche principali della classe Future

Classe Future nel modulo asyncio rappresenta il risultato di un'operazione asincrona che sarà disponibile in futuro. Gli oggetti Future sono utilizzati per gestire lo stato e i risultati delle attività asincrone.

Caratteristiche principali della classe Future

L'oggetto Future è un contenitore per il risultato, che sarà disponibile più tardi, al termine dell'esecuzione dell'attività. Fornisce un'interfaccia per ottenere il risultato o l'eccezione, che saranno impostati al termine dell'operazione asincrona.

Creazione e gestione degli oggetti Future

• Creazione: Di solito viene creato utilizzando loop.create_future().
• Impostazione del risultato: Il risultato viene impostato tramite il metodo set_result(result).
• Impostazione dell'eccezione: L'eccezione viene impostata tramite il metodo set_exception(exception).

Metodi e attributi principali

set_result(result):

Imposta il risultato per l'oggetto Future. Tutte le coroutine che aspettano questo oggetto, verranno immediatamente riprese con questo risultato.

set_exception(exception):

Imposta l'eccezione per l'oggetto Future. Tutte le coroutine che aspettano questo oggetto, verranno immediatamente riprese con questa eccezione.

result():

Restituisce il risultato dell'oggetto Future, se disponibile. Se l'operazione è terminata con un'eccezione, solleverà questa eccezione.

exception():

Restituisce l'eccezione, se è stata impostata, o None, se l'oggetto Future non è ancora terminato o è terminato con successo.

done():

Restituisce True, se l'oggetto Future è terminato (con risultato o eccezione).

add_done_callback(callback):

Aggiunge un callback che verrà chiamato al termine dell'oggetto Future.

8.2 Esempi di utilizzo

Impostazione e ottenimento del risultato

import asyncio

async def set_future_result(fut, delay):
    await asyncio.sleep(delay)
    fut.set_result("Future result is ready")
            
async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()
    asyncio.create_task(set_future_result(fut, 2))
    result = await fut
    print(result)
            
asyncio.run(main())

Gestione delle eccezioni

import asyncio

async def set_future_exception(fut, delay):
    await asyncio.sleep(delay)
    fut.set_exception(ValueError("An error occurred"))
            
async def main():
    loop = asyncio.get_running_loop()
    fut = loop.create_future()
    asyncio.create_task(set_future_exception(fut, 2))
    try:
        result = await fut
    except ValueError as e:
        print(f"Caught an exception: {e}")

asyncio.run(main())

Interazione con i task

Spesso gli oggetti Future vengono utilizzati in combinazione con i task (Tasks). Quando un task viene creato tramite asyncio.create_task(), viene automaticamente creato un oggetto Future, che può essere utilizzato per monitorare e gestire lo stato del task.

import asyncio

async def example_coroutine():
    await asyncio.sleep(1)
    return "Task result"
            
async def main():
    task = asyncio.create_task(example_coroutine())
    print(await task)
            
asyncio.run(main())

8.3 Vantaggi e caratteristiche

Gli oggetti Future consentono di gestire i risultati e le eccezioni delle operazioni asincrone, garantendo flessibilità e controllo sull'esecuzione. Future può essere utilizzato in diversi scenari di programmazione asincrona, comprese attività, timer, callback e molto altro.

Spesso gli oggetti Future vengono utilizzati in combinazione con i task (Tasks). Questo approccio consente di ottenere un livello più elevato di controllo sull'esecuzione e lo stato delle operazioni asincrone.

Limitazioni

In alcuni casi, l'uso di Future può essere più complesso rispetto all'uso di astrazioni di livello superiore, come i task (Tasks) o le coroutine. Utilizzando Future potrebbe essere necessario un maggiore controllo manuale dello stato e dei risultati delle operazioni asincrone.