Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Millal kasutada asünkroonset vs sünkroonset lähenemist

Õppetund 3 / 12 Värskendatud 30. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Valik pole alati ilmne
  2. Millal sünkroonne lähenemine piisab
  3. Millal asünkroonne lähenemine on vajalik
  4. Enneaegse asünkroonsuse lõks
  5. Otsustuspuu
  6. Peamised punktid

Valik pole alati ilmne

Asünkroonne lähenemine ei ole automaatselt parem sünkroonsest. Mõlemal meetodil on olukordi, kus see hiilgab, ja vale valik võib su koodi keeruliseks muuta ilma jõudluse kasuta. See tund aitab sul otsustada, millist lähenemist oma olukorras rakendada.

Millal sünkroonne lähenemine piisab

Sünkroonne klient on õige valik sagedamini, kui arvata oskad, ja põhjus on alati sama: kui paralleelsus midagi ei lisa, on selle keerukus puhas kahju. Ühekordne test või uurimisskript, mis saadab paar päringut, ei võida asünkroonsusest midagi – koodi lihtsus on esikohal ja sa loed seda skripti kuue kuu pärast uuesti läbi. Järjestikuses torustikus, kus iga päring sõltub eelmise tulemusest, ei saa niikuinii midagi paralleelselt teha: asünkroonsus lisaks ainult süntaksit, muutmata täitmisaega sekunditki. Sama loogika kehtib traditsioonilise Django rakenduse kohta: kui sinu virn pole asünkroonne, tekitab asyncio lisamine ainult API päringute jaoks valusa sünkroonse/asünkroonse piiri, mida on raske hallata. Ja prototüüpimise faasis, kui testid vihjet või kinnitad kontseptsiooni, on sünkroonne kood kiiremini loetav ja kirjutatav – täpselt seda, mida prototüübilt ootad.

# Sünkroonne – ideaalne järjestikuse torustiku jaoks
from openai import OpenAI

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

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

# 2. samm: kokkuvõtte genereerimine analüüsi põhjal
summary = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content

Selles näites sõltub 2. samm 1. sammu tulemusest. Asünkroonsus ei paku mingit eelist.

Millal asünkroonne lähenemine on vajalik

Asünkroonsus muutub hädavajalikuks niipea, kui võrgu latentsus domineerib su täitmisaega ja päringud on sõltumatud. Õpikunäide on partii töötlemine: tosinad või sajad päringud ilma omavaheliste sõltuvusteta, kus võit on võrdeline mahuga – sada kahe sekundilist päringut võtab järjestikuses täitmises kolm minutit, kontrollitud paralleelsuses aga umbes kümme sekundit. Teine juhtum pole valik, vaid nõue: FastAPI või Starlette rakenduses on raamistik juba asünkroonne ja sünkroonse kliendi kasutamine seal blokeeriks sündmuste ahela – iga Grok-i kutse külmutaks kõik muud päringud su serverisse. Siis on veel loomulikult samaaegsed arhitektuurid: vestlusrobot, mis päringutab Grok-i, andmebaasi ja välist API-d paralleelselt vastuse koostamiseks, või jälgimissüsteem, mis jälgib korraga mitut voogu – asünkroonsus on seal lihtsalt probleemile loomulik lahendus.

# Asünkroonne – 50 küsimuse töötlemine paralleelselt
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])

50 küsimuse ja 5-lubaga semaforiga töötled korraga 5 päringut ühe asemel. Kui iga päring võtab 8 sekundit, väheneb koguaeg 400 sekundilt umbes 80 sekundile.

Enneaegse asünkroonsuse lõks

Halvasti disainitud asünkroonne kood on halvem kui hästi kirjutatud sünkroonne kood. Siin on levinud vead:

Sündmuste ahela blokeerimine

# HALB: sünkroonne kutse asünkroonses funktsioonis
async def bad_example():
    response = requests.get("https://api.example.com")  # blokeerib kõike
    return response.json()

Teek requests on sünkroonne. Selle kutsumine korutiinis blokeerib sündmuste ahela ja tühistab asünkroonsuse kõik eelised. Kasuta selle asemel httpx või aiohttp.

Põhjendamatu keerukus

# HALB: asünkroonsus ühe päringu jaoks
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Sünkroonne ekvivalent, lihtsam
def simple():
    response = client.chat.completions.create(...)
    return response

Kui sul on saata ainult üks päring, lisab asünkroonsus keerukust ilma kasuta.

Otsustuspuu

Sünkroonse ja asünkroonse vahel valimiseks esita endale need küsimused selles järjekorras:

  1. Mitu API päringut sa saadad? Kui üks või paar järjestikku, jää sünkroonse juurde.
  2. Kas päringud on sõltumatud? Kui iga päring sõltub eelmisest, jää sünkroonse juurde.
  3. Kas su raamistik on asünkroonne? Kui jah (FastAPI, Starlette, aiohttp), kasuta asünkroonset, et vältida sündmuste ahela blokeerimist.
  4. Kas kogutöötlusaeg on probleem? Kui töötled partiisid ja sünkroonne aeg on vastuvõetamatu, lülitu asünkroonsele.

Peamised punktid

  • Sünkroonne töötab lihtsate skriptide, järjestikuste torustike ja prototüüpimise jaoks
  • Asünkroonne on vajalik partii töötlemisel, asünkroonsetes raamistikes ja paralleelsete päringute korral
  • Ära kunagi kasuta sünkroonseid teeke (requests) asünkroonses koodis
  • Asünkroonsuse lisatud keerukus peab olema mõõdetava kasuga põhjendatud
  • Alusta sünkroonselt ja migreeru asünkroonsele, kui vajadus on kinnitatud