Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Wanneer u async versus sync moet gebruiken

Les 3 van 12 Bijgewerkt op 30 juli 2026 Gevorderd
Op deze pagina
  1. De keuze is niet altijd evident
  2. Wanneer sync volstaat
  3. Wanneer async noodzakelijk is
  4. De valkuil van voortijdige async
  5. Beslissingsboom
  6. Belangrijkste punten

De keuze is niet altijd evident

Async is niet automatisch superieur aan sync. Elke aanpak heeft contexten waarin deze uitblinkt, en het kiezen van de verkeerde optie kan uw code onnodig compliceren zonder prestatiewinst. Deze les helpt u te beslissen welke aanpak u voor uw situatie moet adopteren.

Wanneer sync volstaat

De sync-client blijft vaker de juiste keuze dan u misschien denkt, en de reden is altijd dezelfde: wanneer parallelisme niets toevoegt, is de complexiteit een nettoverlies. Een eenmalige test of een exploratiescript dat enkele verzoeken verzendt, heeft niets aan async; eenvoud van code gaat voor, en u zult dit script over zes maanden opnieuw lezen. Een sequentiële pipeline waarbij elk verzoek afhangt van het vorige resultaat, kan toch niets paralleliseren: async voegt alleen syntaxis toe zonder de uitvoeringstijd ook maar een seconde te veranderen. Dezelfde logica geldt voor een traditionele Django-toepassing: als uw stack niet async is, creëert het toevoegen van asyncio alleen voor API-aanroepen een sync/async-grens die pijnlijk is om te onderhouden. En in de prototypefase, wanneer u een prompt test of een concept valideert, is sync-code sneller te lezen en te schrijven; precies wat u van een prototype wilt.

# Sync — perfect voor een sequentiële pipeline
from openai import OpenAI

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

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

# Stap 2: genereer een samenvatting op basis van de analyse
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 dit voorbeeld hangt stap 2 af van het resultaat van stap 1. Async biedt geen enkel voordeel.

Wanneer async noodzakelijk is

Async wordt essentieel zodra netwerklatentie uw uitvoeringstijd domineert en de verzoeken onafhankelijk zijn. Het schoolvoorbeeld is batchverwerking: tientallen of honderden verzoeken zonder onderlinge afhankelijkheden, waarbij de winst evenredig is met het volume; honderd verzoeken van twee seconden duren in sequentie drie minuten, maar bij gecontroleerde parallelisatie ongeveer tien seconden. Het tweede geval is geen keuze maar een vereiste: in een FastAPI- of Starlette-toepassing is het framework al async, en het gebruik van een sync-client zou daar de event loop blokkeren; elke aanroep naar Grok zou alle andere verzoeken naar uw server bevriezen. Dan zijn er nog de van nature concurrente architecturen: een chatbot die parallel Grok, een database en een externe API bevraagt om zijn antwoord samen te stellen, of een monitoringssysteem dat meerdere streams tegelijk bekijkt; async is daar simpelweg de natuurlijke pasvorm voor het probleem.

# Async — 50 vragen parallel verwerken
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])

Met 50 vragen en een semaphore van 5 verwerkt u 5 verzoeken parallel in plaats van één. Als elk verzoek 8 seconden duurt, daalt de totale tijd van 400 seconden naar ongeveer 80 seconden.

De valkuil van voortijdige async

Slecht ontworpen async-code is slechter dan goed geschreven sync-code. Hier zijn veelgemaakte fouten:

De event loop blokkeren

# SLECHT: sync-aanroep in een async-functie
async def bad_example():
    response = requests.get("https://api.example.com")  # blokkeert alles
    return response.json()

De requests-bibliotheek is sync. Het aanroepen ervan in een coroutine blokkeert de event loop en tenietdoet elk voordeel van async. Gebruik in plaats daarvan httpx of aiohttp.

Onnodige complexiteit

# SLECHT: async voor een enkel verzoek
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Sync-equivalent, eenvoudiger
def simple():
    response = client.chat.completions.create(...)
    return response

Als u slechts één verzoek hoeft te verzenden, voegt async complexiteit toe zonder voordeel.

Beslissingsboom

Stel uzelf bij de keuze tussen sync en async deze vragen in volgorde:

  1. Hoeveel API-verzoeken verzendt u? Bij één of enkele in sequentie, blijf bij sync.
  2. Zijn de verzoeken onafhankelijk? Als elk verzoek afhangt van het vorige, blijf bij sync.
  3. Is uw framework async? Zo ja (FastAPI, Starlette, aiohttp), gebruik dan async om blokkering van de event loop te voorkomen.
  4. Is de totale verwerkingstijd een probleem? Als u batches verwerkt en de sync-tijd onaanvaardbaar is, schakel dan over op async.

Belangrijkste punten

  • Sync werkt voor eenvoudige scripts, sequentiële pipelines en prototyping
  • Async is noodzakelijk voor batchverwerking, async-frameworks en parallelle verzoeken
  • Gebruik nooit sync-bibliotheken (requests) in async-code
  • De door async toegevoegde complexiteit moet gerechtvaardigd worden door meetbare winst
  • Begin met sync en migreer naar async wanneer de noodzaak bevestigd is