Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Hvornår skal du bruge Async kontra Sync

Lektion 3 af 12 Opdateret 30. juli 2026 Avanceret
På denne side
  1. Valget er ikke altid indlysende
  2. Hvornår Sync er nok
  3. Hvornår Async er nødvendigt
  4. Fælden med for tidlig Async
  5. Beslutningstræ
  6. Vigtige pointer

Valget er ikke altid indlysende

Async er ikke automatisk bedre end sync. Hver tilgang har sammenhænge, hvor den excellerer, og at vælge forkert kan komplicere din kode uden at give nogen gevinst i ydeevnen. Denne lektion hjælper dig med at beslutte, hvilken tilgang du skal vælge til din situation.

Hvornår Sync er nok

Sync-klienten er ofte det rigtige valg, oftere end du måske tror, og årsagen er altid den samme: når parallelisering ikke tilfører noget, er kompleksiteten en ren omkostning. Et engangstest- eller udforskningsscript, der sender nogle få forespørgsler, vinder intet ved async – kodens enkelhed kommer først, og du vil læse dette script igen om seks måneder. En sekventiel pipeline, hvor hver forespørgsel afhænger af resultatet af den forrige, kan alligevel ikke parallelisere noget: async ville blot tilføje syntaks uden at ændre eksekveringstiden med et sekund. Samme logik gælder for en traditionel Django-applikation: hvis din stack ikke er async, vil det at tilføje asyncio kun til API-kald skabe en sync/async-grænseflade, der er smertefuld at vedligeholde. Og i prototypefasen, når du tester en prompt eller validerer et koncept, er sync-kode hurtigere at læse og skrive – præcis det, du ønsker af en prototype.

# Sync — perfekt til en sekventiel pipeline
from openai import OpenAI

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

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

# Trin 2: generer et resumé baseret på analysen
summary = client.chat.completions.create(
    model="grok-4.5",
    messages=[{"role": "user", "content": f"Summary based on this analysis: {analysis}"}]
).choices[0].message.content

I dette eksempel afhænger trin 2 af resultatet fra trin 1. Async tilbyder ingen fordel.

Hvornår Async er nødvendigt

Async bliver essentielt, så snart netværkslatens dominerer din eksekveringstid, og forespørgslerne er uafhængige. Det klassiske tilfælde er batch-behandling: dusinvis eller hundredvis af forespørgsler uden afhængigheder imellem dem, hvor gevinsten er proportional med volumenet – hundrede forespørgsler på to sekunder tager tre minutter i sekvens, men omkring ti sekunder ved kontrolleret parallelisering. Det andet tilfælde er ikke et valg, men et krav: i en FastAPI- eller Starlette-applikation er frameworket allerede async, og brug af en sync-klient her ville blokere event loop’en – hvert kald til Grok ville fryse alle andre forespørgsler til din server. Så er der naturligt samtidige arkitekturer: en chatbot, der spørger Grok, en database og en ekstern API parallelt for at sammensætte sit svar, eller et overvågningssystem, der holder øje med flere streams på én gang – async er simpelthen den naturlige løsning på problemet her.

# Async — behandling af 50 spørgsmål parallelt
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])

Med 50 spørgsmål og en semaphore på 5 behandler du 5 forespørgsler parallelt i stedet for én. Hvis hver forespørgsel tager 8 sekunder, falder den samlede tid fra 400 sekunder til omkring 80 sekunder.

Fælden med for tidlig Async

Dårligt designet async-kode er værre end velskrevet sync-kode. Her er nogle almindelige fejl:

Blokering af Event Loop’en

# DÅRLIGT: sync-kald i en async-funktion
async def bad_example():
    response = requests.get("https://api.example.com")  # blokerer alt
    return response.json()

Biblioteket requests er sync. At kalde det i en coroutine blokerer event loop’en og ophæver enhver fordel ved async. Brug i stedet httpx eller aiohttp.

Unødvendig kompleksitet

# DÅRLIGT: async til en enkelt forespørgsel
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Sync-ækvivalent, enklere
def simple():
    response = client.chat.completions.create(...)
    return response

Hvis du kun har én forespørgsel at sende, tilføjer async kompleksitet uden fordel.

Beslutningstræ

For at vælge mellem sync og async skal du stille dig selv disse spørgsmål i rækkefølge:

  1. Hvor mange API-forespørgsler sender du? Hvis det er én eller få i sekvens, så bliv ved sync.
  2. Er forespørgslerne uafhængige? Hvis hver forespørgsel afhænger af den forrige, så bliv ved sync.
  3. Er dit framework async? Hvis ja (FastAPI, Starlette, aiohttp), så brug async for at undgå at blokere event loop’en.
  4. Er den samlede behandlingstid et problem? Hvis du behandler batches, og sync-tiden er uacceptabel, så skift til async.

Vigtige pointer

  • Sync fungerer til enkle scripts, sekventielle pipelines og prototyping
  • Async er nødvendigt til batch-behandling, async frameworks og parallelle forespørgsler
  • Brug aldrig sync-biblioteker (requests) i async-kode
  • Kompleksiteten tilføjet af async skal retfærdiggøres af målbare gevinster
  • Start med sync, og migrer til async, når behovet er bekræftet