Classe Future

8.1 Características principais da classe Future

A classe Future no módulo asyncio representa o resultado de uma operação assíncrona que estará disponível futuramente. Objetos Future são usados para gerenciar o estado e os resultados de tarefas assíncronas.

Características principais da classe Future

O objeto Future é um contêiner para um resultado que será disponível depois que a tarefa terminar de ser executada. Ele fornece uma interface para obter um resultado ou exceção que será definido após a conclusão da operação assíncrona.

Criação e gestão de objetos Future

• Criação: Normalmente criado usando loop.create_future().
• Definindo o resultado: O resultado é definido usando o método set_result(result).
• Definindo a exceção: A exceção é definida usando o método set_exception(exception).

Métodos e atributos principais

set_result(result):

Define o resultado para o objeto Future. Todas as corotinas que aguardam esse objeto serão imediatamente retomadas com esse resultado.

set_exception(exception):

Define uma exceção para o objeto Future. Todas as corotinas que aguardam esse objeto serão imediatamente retomadas com essa exceção.

result():

Retorna o resultado do objeto Future, se estiver disponível. Se a operação terminou com uma exceção, essa exceção será lançada.

exception():

Retorna a exceção, se estiver definida, ou None, se o objeto Future ainda não foi concluído ou foi concluído com sucesso.

done():

Retorna True se o objeto Future estiver concluído (com um resultado ou exceção).

add_done_callback(callback):

Adiciona um callback que será chamado quando o objeto Future for concluído.

8.2 Exemplos de uso

Definindo e obtendo o resultado

import asyncio

async def set_future_result(fut, delay):
    await asyncio.sleep(delay)
    fut.set_result("O resultado do Future está pronto")
            
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())

Tratamento de exceções

import asyncio

async def set_future_exception(fut, delay):
    await asyncio.sleep(delay)
    fut.set_exception(ValueError("Ocorreu um erro"))
            
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"Pegou uma exceção: {e}")

asyncio.run(main())

Interação com tarefas

Muitas vezes, objetos Future são usados em conjunto com tarefas (Tasks). Quando uma tarefa é criada com asyncio.create_task(), ela automaticamente cria um objeto Future que pode ser usado para rastrear e gerenciar o estado da tarefa.

import asyncio

async def example_coroutine():
    await asyncio.sleep(1)
    return "Resultado da Tarefa"
            
async def main():
    task = asyncio.create_task(example_coroutine())
    print(await task)
            
asyncio.run(main())

8.3 Vantagens e características

Objetos Future permitem gerenciar resultados e exceções de operações assíncronas, proporcionando flexibilidade e controle sobre a execução. Future pode ser usado em diversos cenários de programação assíncrona, incluindo tarefas, temporizadores, callbacks e muito mais.

Frequentemente, objetos Future são usados em conjunto com tarefas (Tasks). Essa abordagem permite obter um nível mais alto de controle sobre a execução e o estado das operações assíncronas.

Limitações

Em alguns casos, o uso de Future pode ser mais complexo em comparação com o uso de abstrações de nível superior, como tarefas (Tasks) ou corotinas. Ao usar Future pode ser necessário mais gerenciamento manual do estado e dos resultados das operações assíncronas.