Métodos Populares do asyncio

4.1 Método run()

O módulo asyncio fornece muitos métodos e funções para criar e gerenciar programas assíncronos. Aqui estão alguns dos métodos e funções mais populares e frequentemente usados do módulo asyncio.

Hoje vamos ver os 4 mais comuns:

• run()
• sleep()
• wait()
• gather()

Agora com mais detalhes:

Método asyncio.run(coroutine)

Este método é usado para rodar um programa assíncrono. Ele é especialmente útil quando você quer executar um código assíncrono a partir de um contexto síncrono, como o thread principal do programa.

O método asyncio.run() executa a corotina principal e gerencia a criação e fechamento do loop de eventos. Este método cria automaticamente um novo loop de eventos e o finaliza ao concluir a execução da corotina.

Assinatura:

asyncio.run(async_function(), *, debug=False)
        

• async_function: A corotina que precisa ser executada.
• debug: Parâmetro opcional que ativa o modo debug para o loop de eventos.

Exemplo de uso:

import asyncio

async def main():
    print('Hello')
    await asyncio.sleep(1)
    print('World')
            
asyncio.run(main())
        

Restrições

Não pode ser chamado de dentro de outro loop de eventos:

asyncio.run() deve ser chamado apenas a partir de código síncrono, pois ele cria e finaliza seu próprio loop de eventos. Tentar chamá-lo de dentro de um loop de eventos já existente irá gerar um erro.

Apenas para o nível superior:

Este método é projetado para rodar o ponto de entrada principal do programa e não deve ser usado para chamadas aninhadas de funções assíncronas.

4.2 Método sleep()

Este método é usado quando você precisa pausar a execução de uma corotina por um tempo específico, sem bloquear a execução de outras corotinas.

O método asyncio.sleep() no módulo asyncio é usado para pausar a execução da corotina atual por um número de segundos especificado.

Este método difere do método similar time.sleep() em que permite que outras tarefas sejam executadas durante a pausa. Isso o torna útil para escrever programas assíncronos que requerem atrasos ou espera sem bloquear o thread principal.

Assinatura:

asyncio.sleep(delay, result=None)
        

• delay: Tempo de atraso em segundos (pode ser um número fracionário).
• result: Resultado opcional que será retornado após o atraso.

Exemplo de aplicação:

import asyncio

async def main():
    print('Start sleeping')
    await asyncio.sleep(2)
    print('Wake up')
            
asyncio.run(main())
        

Neste exemplo, a corotina main é pausada por 2 segundos, permitindo que outras tarefas sejam executadas durante esse tempo, e em seguida continua e imprime "Wake up".

4.3 Método wait()

Este método é útil quando você precisa esperar que várias operações assíncronas sejam concluídas, mas quer um controle mais refinado sobre o processo de espera.

O método asyncio.wait() no módulo asyncio permite que você espere pela conclusão de várias tarefas assíncronas ou corotinas. Você pode esperar que todas as tarefas sejam concluídas, a primeira tarefa concluída ou qualquer tarefa com erro.

Ao contrário de gather(), o método wait() oferece mais controle sobre o processo de espera, permitindo definir tempo limite e condições de término.

Características principais do método asyncio.wait()

Assinatura:

asyncio.wait(fs, *, timeout=None, return_when=ALL_COMPLETED)
        

Onde:

• fs: Coleção de objetos Future ou corotinas que precisam ser esperados.
• timeout: Parâmetro opcional que especifica o tempo máximo de espera em segundos. Se o tempo expirar, o método retorna as tarefas que foram concluídas até aquele momento.
• return_when: Condição que define quando o método deve terminar. Valores possíveis:
  • ALL_COMPLETED: O método retorna o resultado quando todas as tarefas são concluídas (padrão).
  • FIRST_COMPLETED: O método retorna o resultado quando a primeira tarefa é concluída.
  • FIRST_EXCEPTION: O método retorna o resultado quando qualquer tarefa é concluída com exceção.

Espera pela conclusão de várias tarefas ou corotinas. Você pode especificar tempo de espera e condições de término.

import asyncio

async def say(what, delay):
    await asyncio.sleep(delay)
    return what
            
async def main():
    task1 = asyncio.create_task(say('hello', 1)) 
    task2 = asyncio.create_task(say('world', 2))
    done, pending = await asyncio.wait([task1, task2], timeout=1.5)
    for task in done:
        print(task.result())
            
asyncio.run(main())
        

No exemplo acima, envolvemos cada corotina say() em um objeto Task usando o método create_task(), e então passamos a lista dessas tarefas para o método wait(). Objetos Task permitem que as corotinas sejam executadas em paralelo, sem esperar que uma termine antes de iniciar outra.

O método wait irá esperar pelas tarefas apenas um segundo e meio, após o que irá retornar uma tupla das tarefas: o primeiro valor da tupla conterá as tarefas que conseguiram ser concluídas (done), o segundo — as que ainda estão em execução (pending).

4.4 Método gather()

Este método é especialmente útil quando você precisa executar várias operações assíncronas em paralelo e obter seus resultados em forma de lista.

O método asyncio.gather() no módulo asyncio é usado para executar várias tarefas assíncronas em paralelo e retornar seus resultados como uma lista. É uma maneira conveniente de agrupar corotinas ou tarefas e esperar por sua conclusão.

Características principais do método asyncio.gather()

Assinatura:

asyncio.gather(*coros_or_futures, return_exceptions=False)
        

Onde:

• coros_or_futures: Corotinas ou objetos Future que devem ser executados.
• return_exceptions: Valor booleano que indica se as exceções devem ser retornadas como resultados. Por padrão, é False.

Exemplo de uso

import asyncio

async def say_after(delay, what):
    await asyncio.sleep(delay)
    return what
            
async def main():
    results = await asyncio.gather(
        say_after(1, 'hello'),
        say_after(2, 'world')
    )
    print(results)
            
asyncio.run(main())
        

Este exemplo mostra como asyncio.gather pode ser usado para executar várias tarefas em paralelo, cada uma com seu próprio atraso. Os resultados de todas as tarefas são retornados como uma lista. Ao contrário de wait, gather não apenas espera que as tarefas sejam concluídas, mas também coleta os resultados de todas as corotinas, tornando-o conveniente para casos em que o resultado de cada tarefa é importante.