Asyncio Python: como usar para código assíncrono

O que é programação assíncrona e por que você precisa dela

A programação assíncrona permite executar várias operações simultaneamente sem precisar esperar a conclusão de cada uma delas. Isso é essencial para criar aplicações de alto desempenho que não travam ao realizar operações lentas.

Principais vantagens da assincronicidade

A assincronicidade é especialmente eficaz nos seguintes cenários:

• Requisições de rede (requisições HTTP, consumo de APIs REST)
• Operações com sistema de arquivos (leitura e escrita de arquivos grandes)
• Interação com bancos de dados (consultas SQL, operações NoSQL)
• Conexões WebSocket e aplicações em tempo real
• Web scraping e extração de dados
• Processamento de filas de mensagens

Introdução à biblioteca asyncio

asyncio é a biblioteca padrão do Python para escrever código assíncrono baseado em um loop de eventos (event loop). A biblioteca faz parte do Python desde a versão 3.4 e foi significativamente aprimorada nas versões 3.7+.

Principais recursos do asyncio

Com asyncio você pode:

• Criar e gerenciar corrotinas
• Executar múltiplas tarefas assíncronas em paralelo
• Processar milhares de conexões simultâneas de forma eficiente
• Integrar com bibliotecas e frameworks assíncronos

Conceitos fundamentais do asyncio

Corrotinas (Coroutines)

Uma corrotina é uma função especial que pode ser pausada e posteriormente retomada. Em Python, corrotinas são definidas com a palavra-chave async def.

import asyncio

async def saudacao():
    print("Olá!")
    await asyncio.sleep(1)
    print("Passou 1 segundo.")

# Executando a corrotina
asyncio.run(saudacao())

A palavra-chave await

await é usada para pausar a execução de uma corrotina até que outra operação assíncrona seja concluída. Este é o mecanismo chave para devolver o controle ao event loop.

async def mensagem_atrasada():
    print("Início da execução")
    await asyncio.sleep(2)
    print("Mensagem após 2 segundos")

asyncio.run(mensagem_atrasada())

Event Loop (Loop de Eventos)

O Event Loop é o coração do asyncio, o mecanismo que gerencia a execução de todas as tarefas assíncronas. A partir do Python 3.7, recomenda-se usar asyncio.run() para executar código assíncrono.

# Forma moderna (Python 3.7+)
asyncio.run(corrotina_principal())

# Forma antiga (antes do Python 3.7)
loop = asyncio.get_event_loop()
loop.run_until_complete(corrotina_principal())

Criando e gerenciando tarefas assíncronas

Execução paralela de tarefas

O código assíncrono mostra seu poder ao executar várias tarefas em paralelo:

async def tarefa(nome, delay):
    print(f"Tarefa {nome} iniciada")
    await asyncio.sleep(delay)
    print(f"Tarefa {nome} concluída após {delay} segundos")
    return f"Resultado de {nome}"

async def main():
    # Método 1: asyncio.gather()
    resultados = await asyncio.gather(
        tarefa("A", 2),
        tarefa("B", 1),
        tarefa("C", 3)
    )
    print("Todos os resultados:", resultados)

asyncio.run(main())

Criando tarefas com asyncio.create_task()

Para ter mais controle sobre a execução, use asyncio.create_task():

async def main():
    # Criando tarefas
    tarefa_a = asyncio.create_task(tarefa("A", 2))
    tarefa_b = asyncio.create_task(tarefa("B", 1))
    tarefa_c = asyncio.create_task(tarefa("C", 3))
    
    # Aguardando a conclusão
    await tarefa_a
    await tarefa_b
    await tarefa_c

asyncio.run(main())

Requisições HTTP assíncronas

Instalação e uso