Criando e Executando Corrotinas

Para começar a trabalhar com programação assíncrona em Python, é necessário compreender as corrotinas. Uma corrotina é uma função especial definida com async def. Corrotinas permitem pausar e retomar a execução, tornando possível lidar com tarefas como operações de entrada/saída - como leitura de arquivos, requisições de rede ou consultas a bancos de dados - sem bloquear todo o programa. Isso significa que, enquanto uma tarefa aguarda dados, outras podem continuar em execução, aumentando a eficiência e a capacidade de resposta.

Para executar uma corrotina, utiliza-se asyncio.run, que inicia um loop de eventos, executa a corrotina e encerra o loop ao final. Este é o método padrão para iniciar código assíncrono no Python moderno.

Caso seja necessário executar mais de uma corrotina ao mesmo tempo, pode-se usar asyncio.gather para agendá-las concorrentemente. Isso permite que o programa inicie várias tarefas e aguarde todas terminarem, aproveitando melhor o tempo, especialmente ao lidar com operações lentas como I/O.

O código a seguir demonstra esses conceitos.

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())

Resultado esperado:

Hello, Bob!
Hello, Alice!

A saudação de Bob aparece primeiro porque utiliza um atraso menor (1 segundo) do que a de Alice (2 segundos).

A coroutine greet é criada com async def, permitindo pausar a execução com await asyncio.sleep(delay) antes de exibir uma saudação. A coroutine main agenda duas instâncias de greet — uma para "Alice" com atraso de 2 segundos e outra para "Bob" com atraso de 1 segundo — utilizando asyncio.gather. Isso significa que ambas as saudações são tratadas concorrentemente, de modo que o programa não espera uma terminar para iniciar a outra. Por fim, asyncio.run(main()) inicia o loop de eventos, executa a coroutine main e garante que tudo seja finalizado corretamente. Essa abordagem permite lidar com várias tarefas que envolvem espera (como requisições de rede ou atrasos de tempo) ao mesmo tempo, tornando o programa mais eficiente e responsivo.