Ir al contenido principal
Español— Elegir un idioma
Menú

Cuándo usar asíncrono frente a síncrono

Lección 3 de 12 Actualizado el 30 de julio de 2026 Avanzado
En esta página
  1. La elección no siempre es obvia
  2. Cuándo es suficiente con síncrono
  3. Cuándo es necesario asíncrono
  4. La trampa del asíncrono prematuro
  5. Árbol de decisiones
  6. Puntos clave

La elección no siempre es obvia

El código asíncrono no es automáticamente superior al síncrono. Cada enfoque tiene contextos donde destaca, y elegir el incorrecto puede complicar tu código sin aportar mejoras de rendimiento. Esta lección te ayuda a decidir qué enfoque adoptar para tu situación.

Cuándo es suficiente con síncrono

El cliente síncrono sigue siendo la opción correcta más a menudo de lo que podrías pensar, y la razón es siempre la misma: cuando el paralelismo no aporta nada, su complejidad es un coste neto. Un script de prueba o exploración puntual que envía unas pocas peticiones no gana nada con asíncrono; la simplicidad del código es lo primero, y volverás a leer ese script dentro de seis meses. Una canalización secuencial donde cada petición depende del resultado anterior no puede paralelizar nada de todos modos: asíncrono añadiría sintaxis sin cambiar el tiempo de ejecución ni un segundo. La misma lógica se aplica a una aplicación Django tradicional: si tu pila no es asíncrona, añadir asyncio solo para llamadas a la API crea una frontera síncrono/asíncrono dolorosa de mantener. Y en la fase de prototipado, cuando estás probando un prompt o validando un concepto, el código síncrono es más rápido de leer y escribir; exactamente lo que quieres de un prototipo.

# Síncrono — perfecto para una canalización secuencial
from openai import OpenAI

client = OpenAI(api_key=os.getenv("XAI_API_KEY"), base_url="https://api.x.ai/v1")

# Paso 1: analizar el texto
analysis = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Analyze this text: {text}"}]
).choices[0].message.content

# Paso 2: generar un resumen basado en el análisis
summary = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content

En este ejemplo, el paso 2 depende del resultado del paso 1. Asíncrono no ofrece ningún beneficio.

Cuándo es necesario asíncrono

Asíncrono se vuelve esencial tan pronto como la latencia de red domina tu tiempo de ejecución y las peticiones son independientes. El caso de libro de texto es el procesamiento por lotes: docenas o cientos de peticiones sin dependencias entre ellas, donde la ganancia es proporcional al volumen; cien peticiones de dos segundos tardan tres minutos en secuencia, alrededor de diez segundos con paralelismo controlado. El segundo caso no es una elección, sino un requisito: en una aplicación FastAPI o Starlette, el framework ya es asíncrono, y usar un cliente síncrono allí bloquearía el bucle de eventos; cada llamada a Grok congelaría todas las demás peticiones a tu servidor. Luego están las arquitecturas naturalmente concurrentes: un chatbot que consulta a Grok, una base de datos y una API externa en paralelo para componer su respuesta, o un sistema de monitorización que vigila varios flujos a la vez; asíncrono es simplemente el ajuste natural para el problema en esos casos.

# Asíncrono — procesamiento de 50 preguntas en 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])

Con 50 preguntas y un semáforo de 5, procesas 5 peticiones en paralelo en lugar de una. Si cada petición tarda 8 segundos, el tiempo total pasa de 400 segundos a unos 80 segundos.

La trampa del asíncrono prematuro

Un código asíncrono mal diseñado es peor que un código síncrono bien escrito. Estos son errores comunes:

Bloquear el bucle de eventos

# MAL: llamada síncrona en una función asíncrona
async def bad_example():
    response = requests.get("https://api.example.com")  # bloquea todo
    return response.json()

La biblioteca requests es síncrona. Llamarla en una corrutina bloquea el bucle de eventos y anula cualquier beneficio de asíncrono. Usa httpx o aiohttp en su lugar.

Complejidad innecesaria

# MAL: asíncrono para una única petición
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Equivalente síncrono, más simple
def simple():
    response = client.chat.completions.create(...)
    return response

Si solo tienes que enviar una petición, asíncrono añade complejidad sin beneficio.

Árbol de decisiones

Para elegir entre síncrono y asíncrono, hazte estas preguntas en orden:

  1. ¿Cuántas peticiones a la API estás enviando? Si es una o pocas en secuencia, mantente en síncrono.
  2. ¿Son independientes las peticiones? Si cada petición depende de la anterior, mantente en síncrono.
  3. ¿Es asíncrono tu framework? Si es así (FastAPI, Starlette, aiohttp), usa asíncrono para evitar bloquear el bucle de eventos.
  4. ¿Es el tiempo total de procesamiento un problema? Si estás procesando lotes y el tiempo en síncrono es inaceptable, cambia a asíncrono.

Puntos clave

  • Síncrono funciona para scripts simples, canalizaciones secuenciales y prototipado
  • Asíncrono es necesario para procesamiento por lotes, frameworks asíncronos y peticiones paralelas
  • Nunca uses bibliotecas síncronas (requests) en código asíncrono
  • La complejidad añadida por asíncrono debe estar justificada por ganancias medibles
  • Empieza en síncrono, migra a asíncrono cuando la necesidad esté confirmada