Quando Utilizar Async vs Sync
Nesta página
A Escolha Nem Sempre é Óbvia
O modo assíncrono (async) não é automaticamente superior ao síncrono (sync). Cada abordagem tem contextos onde se destaca, e escolher a errada pode complicar o seu código sem trazer ganhos de desempenho. Esta lição ajuda-o a decidir qual abordagem adotar para a sua situação.
Quando o Sync é Suficiente
O cliente síncrono continua a ser a escolha certa mais vezes do que imagina, e a razão é sempre a mesma: quando o paralelismo não acrescenta nada, a sua complexidade é um custo líquido. Um script de teste pontual ou de exploração que envia algumas requisições não ganha nada com o async — a simplicidade do código vem em primeiro lugar, e voltará a ler este script daqui a seis meses. Um pipeline sequencial onde cada requisição depende do resultado anterior não consegue paralelizar nada de qualquer forma: o async adicionaria sintaxe sem alterar o tempo de execução nem por um segundo. A mesma lógica aplica-se a uma aplicação Django tradicional: se a sua pilha tecnológica não é assíncrona, adicionar asyncio apenas para chamadas de API cria uma fronteira sync/async dolorosa de manter. E na fase de prototipagem, quando está a testar um prompt ou a validar um conceito, o código síncrono é mais rápido de ler e escrever — exatamente o que deseja de um protótipo.
# Sync — perfeito para um pipeline sequencial
from openai import OpenAI
client = OpenAI(api_key=os.getenv("XAI_API_KEY"), base_url="https://api.x.ai/v1")
# Passo 1: analisar o texto
analysis = client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": f"Analyze this text: {text}"}]
).choices[0].message.content
# Passo 2: gerar um resumo com base na análise
summary = client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content
Neste exemplo, o passo 2 depende do resultado do passo 1. O async não oferece qualquer benefício.
Quando o Async é Necessário
O async torna-se essencial assim que a latência da rede domina o seu tempo de execução e as requisições são independentes. O caso de escola é o processamento em lote (batch processing): dezenas ou centenas de requisições sem dependências entre si, onde o ganho é proporcional ao volume — cem requisições de dois segundos levam três minutos em sequência, mas cerca de dez segundos com paralelismo controlado. O segundo caso não é uma escolha, mas uma exigência: numa aplicação FastAPI ou Starlette, o framework já é assíncrono, e usar um cliente síncrono bloquearia o loop de eventos — cada chamada ao Grok congelaria todas as outras requisições ao seu servidor. Depois, existem arquiteturas naturalmente concorrentes: um chatbot que consulta o Grok, uma base de dados e uma API externa em paralelo para compor a sua resposta, ou um sistema de monitorização que observa vários fluxos simultaneamente — o async é simplesmente o ajuste natural para o problema nesses cenários.
# Async — processamento de 50 perguntas em paralelo
async def batch_process(questions: list[str]) -> list[str]:
sem = asyncio.Semaphore(5)
async def ask(q: str) -> str:
async with sem:
resp = await client.chat.completions.create(
model="grok-4.5",
messages=[{"role": "user", "content": q}]
)
return resp.choices[0].message.content
return await asyncio.gather(*[ask(q) for q in questions])
Com 50 perguntas e um semáforo de 5, processa 5 requisições em paralelo em vez de uma. Se cada requisição levar 8 segundos, o tempo total passa de 400 segundos para cerca de 80 segundos.
A Armadilha do Async Prematuro
Código assíncrono mal concebido é pior do que código síncrono bem escrito. Eis erros comuns:
Bloqueio do Loop de Eventos
# MAU: chamada síncrona numa função assíncrona
async def bad_example():
response = requests.get("https://api.example.com") # bloqueia tudo
return response.json()
A biblioteca requests é síncrona. Chamá-la numa coroutine bloqueia o loop de eventos e anula qualquer benefício do async. Utilize httpx ou aiohttp em alternativa.
Complexidade Desnecessária
# MAU: async para uma única requisição
async def over_engineered():
response = await client.chat.completions.create(...)
return response
# Equivalente Sync, mais simples
def simple():
response = client.chat.completions.create(...)
return response
Se tiver apenas uma requisição para enviar, o async adiciona complexidade sem benefício.
Árvore de Decisão
Para escolher entre sync e async, coloque-se estas perguntas por ordem:
- Quantas requisições à API está a enviar? Se for uma ou poucas em sequência, mantenha-se no sync.
- As requisições são independentes? Se cada requisição depender da anterior, mantenha-se no sync.
- O seu framework é assíncrono? Se sim (FastAPI, Starlette, aiohttp), utilize async para evitar bloquear o loop de eventos.
- O tempo total de processamento é um problema? Se estiver a processar lotes e o tempo em sync for inaceitável, mude para async.
Pontos-chave
- O sync funciona para scripts simples, pipelines sequenciais e prototipagem
- O async é necessário para processamento em lote, frameworks assíncronos e requisições paralelas
- Nunca utilize bibliotecas síncronas (
requests) em código assíncrono - A complexidade adicionada pelo async deve ser justificada por ganhos mensuráveis
- Comece com sync, migre para async quando a necessidade for confirmada