Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Quando usare Async rispetto a Sync

Lezione 3 di 12 Aggiornata il 30 luglio 2026 Avanzato
In questa pagina
  1. La scelta non è sempre ovvia
  2. Quando Sync è sufficiente
  3. Quando Async è necessario
  4. La trappola dell’Async prematuro
  5. Albero decisionale
  6. Punti chiave

La scelta non è sempre ovvia

Async non è automaticamente superiore a sync. Ogni approccio ha contesti in cui eccelle e scegliere quello sbagliato può complicare il tuo codice senza apportare guadagni di prestazioni. Questa lezione ti aiuta a decidere quale approccio adottare per la tua situazione.

Quando Sync è sufficiente

Il client sync rimane spesso la scelta giusta, più di quanto potresti pensare, e la ragione è sempre la stessa: quando il parallelismo non aggiunge nulla, la sua complessità è un costo netto. Uno script di test o di esplorazione una tantum che invia poche richieste non trae alcun vantaggio da async: la semplicità del codice viene prima di tutto e rileggerai questo script tra sei mesi. Una pipeline sequenziale in cui ogni richiesta dipende dal risultato precedente non può comunque parallelizzare nulla: async aggiungerebbe solo sintassi senza modificare il tempo di esecuzione di un secondo. La stessa logica vale per un’applicazione Django tradizionale: se il tuo stack non è async, aggiungere asyncio solo per le chiamate API crea un confine sync/async doloroso da mantenere. E nella fase di prototipazione, quando stai testando un prompt o validando un concetto, il codice sync è più veloce da leggere e scrivere: esattamente ciò che vuoi da un prototipo.

# Sync — perfetto per una pipeline sequenziale
from openai import OpenAI

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

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

# Passo 2: generare un riepilogo basato sull'analisi
summary = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content

In questo esempio, il passo 2 dipende dal risultato del passo 1. Async non offre alcun vantaggio.

Quando Async è necessario

Async diventa essenziale non appena la latenza di rete domina il tuo tempo di esecuzione e le richieste sono indipendenti. Il caso da manuale è l’elaborazione in batch: decine o centinaia di richieste senza dipendenze tra loro, dove il guadagno è proporzionale al volume: cento richieste da due secondi richiedono tre minuti in sequenza, circa dieci secondi in parallelismo controllato. Il secondo caso non è una scelta ma un requisito: in un’applicazione FastAPI o Starlette, il framework è già async e l’uso di un client sync bloccherebbe il loop degli eventi: ogni chiamata a Grok congelerebbe tutte le altre richieste al tuo server. Poi ci sono le architetture naturalmente concorrenti: un chatbot che interroga Grok, un database e un’API esterna in parallelo per comporre la sua risposta, o un sistema di monitoraggio che osserva diversi flussi contemporaneamente: async è semplicemente la soluzione naturale per il problema in questi casi.

# Async — elaborazione di 50 domande in parallelo
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 domande e un semaforo di 5, elabori 5 richieste in parallelo invece di una. Se ogni richiesta impiega 8 secondi, il tempo totale passa da 400 secondi a circa 80 secondi.

La trappola dell’Async prematuro

Un codice async mal progettato è peggiore di un codice sync ben scritto. Ecco gli errori comuni:

Bloccare il Loop degli Eventi

# SBAGLIATO: chiamata sync in una funzione async
async def bad_example():
    response = requests.get("https://api.example.com")  # blocca tutto
    return response.json()

La libreria requests è sync. Chiamarla in una coroutine blocca il loop degli eventi e annulla qualsiasi vantaggio di async. Usa invece httpx o aiohttp.

Complessità inutile

# SBAGLIATO: async per una singola richiesta
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Equivalente Sync, più semplice
def simple():
    response = client.chat.completions.create(...)
    return response

Se devi inviare solo una richiesta, async aggiunge complessità senza benefici.

Albero decisionale

Per scegliere tra sync e async, poniti queste domande in ordine:

  1. Quante richieste API stai inviando? Se una o poche in sequenza, resta su sync.
  2. Le richieste sono indipendenti? Se ogni richiesta dipende dalla precedente, resta su sync.
  3. Il tuo framework è async? Se sì (FastAPI, Starlette, aiohttp), usa async per evitare di bloccare il loop degli eventi.
  4. Il tempo totale di elaborazione è un problema? Se stai elaborando batch e il tempo sync è inaccettabile, passa ad async.

Punti chiave

  • Sync funziona per script semplici, pipeline sequenziali e prototipazione
  • Async è necessario per l’elaborazione in batch, i framework async e le richieste parallele
  • Non usare mai librerie sync (requests) nel codice async
  • La complessità aggiunta da async deve essere giustificata da guadagni misurabili
  • Inizia con sync, migra ad async quando il bisogno è confermato