Salt la conținutul principal
Română— Alege o limbă
Meniu

Când să utilizați Async față de Sync

Lecția 3 din 12 Actualizată 30 iulie 2026 Avansat
Pe această pagină
  1. Alegerea nu este întotdeauna evidentă
  2. Când Sync este suficient
  3. Când Async este necesar
  4. Capcana Async prematur
  5. Arbore de decizie
  6. Puncte cheie

Alegerea nu este întotdeauna evidentă

Async nu este automat superior lui sync. Fiecare abordare are contexte în care excelează, iar alegerea greșită vă poate complica codul fără a aduce câștiguri de performanță. Această lecție vă ajută să decideți ce abordare să adoptați pentru situația dumneavoastră.

Când Sync este suficient

Clientul sync rămâne alegerea corectă mai des decât ați putea crede, iar motivul este întotdeauna același: atunci când paralelismul nu aduce nimic, complexitatea sa reprezintă un cost net. Un script de testare sau de explorare ocazional care trimite câteva cereri nu câștigă nimic prin async – simplitatea codului primează, iar dumneavoastră veți reciti acest script peste șase luni. Un pipeline secvențial, în care fiecare cerere depinde de rezultatul anterior, nu poate paraleliza oricum nimic: async ar adăuga doar sintaxă fără a schimba timpul de execuție nici măcar cu o secundă. Același raționament se aplică unei aplicații Django tradiționale: dacă stiva dumneavoastră nu este async, adăugarea lui asyncio doar pentru apelurile API creează o frontieră sync/async dureroasă pentru mentenanță. Și în faza de prototipare, când testați un prompt sau validați un concept, codul sync este mai rapid de citit și scris – exact ceea ce doriți de la un prototip.

# Sync — perfect pentru un pipeline secvențial
from openai import OpenAI

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

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

# Pasul 2: generarea unui rezumat bazat pe analiză
summary = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content

În acest exemplu, pasul 2 depinde de rezultatul de la pasul 1. Async nu oferă niciun beneficiu.

Când Async este necesar

Async devine esențial imediat ce latența rețelei domină timpul de execuție, iar cererile sunt independente. Cazul clasic este procesarea în loturi (batch processing): zeci sau sute de cereri fără dependențe între ele, unde câștigul este proporțional cu volumul – o sută de cereri de două secunde durează trei minute în secvență, dar aproximativ zece secunde într-un paralelism controlat. Al doilea caz nu este o alegere, ci o cerință: într-o aplicație FastAPI sau Starlette, framework-ul este deja async, iar utilizarea unui client sync acolo ar bloca bucla de evenimente – fiecare apel către Grok ar îngheța toate celelalte cereri către serverul dumneavoastră. Apoi, există arhitecturi natural concurente: un chatbot care interoghează Grok, o bază de date și un API extern în paralel pentru a-și compune răspunsul, sau un sistem de monitorizare care urmărește mai multe fluxuri simultan – async este pur și simplu soluția naturală pentru această problemă.

# Async — procesarea a 50 de întrebări în paralel
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])

Cu 50 de întrebări și un semafor de 5, procesați 5 cereri în paralel în loc de una singură. Dacă fiecare cerere durează 8 secunde, timpul total scade de la 400 de secunde la aproximativ 80 de secunde.

Capcana Async prematur

Codul async proiectat prost este mai rău decât codul sync bine scris. Iată greșeli comune:

Blocarea buclei de evenimente

# RĂU: apel sync într-o funcție async
async def bad_example():
    response = requests.get("https://api.example.com")  # blochează totul
    return response.json()

Biblioteca requests este sync. Apelarea ei într-o corutină blochează bucla de evenimente și anulează orice beneficiu al async. Utilizați în schimb httpx sau aiohttp.

Complexitate inutilă

# RĂU: async pentru o singură cerere
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Echivalent sync, mai simplu
def simple():
    response = client.chat.completions.create(...)
    return response

Dacă aveți de trimis o singură cerere, async adaugă complexitate fără beneficii.

Arbore de decizie

Pentru a alege între sync și async, puneți-vă următoarele întrebări în ordine:

  1. Câte cereri API trimiteți? Dacă una sau câteva în secvență, rămâneți la sync.
  2. Sunt cererile independente? Dacă fiecare cerere depinde de cea anterioară, rămâneți la sync.
  3. Framework-ul dumneavoastră este async? Dacă da (FastAPI, Starlette, aiohttp), utilizați async pentru a evita blocarea buclei de evenimente.
  4. Este timpul total de procesare o problemă? Dacă procesați loturi, iar timpul sync este inacceptabil, treceți la async.

Puncte cheie

  • Sync funcționează pentru scripturi simple, pipeline-uri secvențiale și prototipare
  • Async este necesar pentru procesarea în loturi, framework-uri async și cereri paralele
  • Nu utilizați niciodată librării sync (requests) în cod async
  • Complexitatea adăugată de async trebuie justificată prin câștiguri măsurabile
  • Începeți cu sync, migrați către async atunci când nevoia este confirmată