Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Quando Utilizar Async vs Sync

Aula 3 de 12 Atualizada a 30 de julho de 2026 Avancado
Nesta página
  1. A Escolha Nem Sempre é Óbvia
  2. Quando o Sync é Suficiente
  3. Quando o Async é Necessário
  4. A Armadilha do Async Prematuro
  5. Árvore de Decisão
  6. Pontos-chave

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:

  1. Quantas requisições à API está a enviar? Se for uma ou poucas em sequência, mantenha-se no sync.
  2. As requisições são independentes? Se cada requisição depender da anterior, mantenha-se no sync.
  3. O seu framework é assíncrono? Se sim (FastAPI, Starlette, aiohttp), utilize async para evitar bloquear o loop de eventos.
  4. 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