Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Wann man Async gegenüber Sync einsetzt

Lektion 3 von 12 Aktualisiert am 30. Juli 2026 Fortgeschritten
Auf dieser Seite
  1. Die Wahl ist nicht immer offensichtlich
  2. Wann Sync ausreicht
  3. Wann Async notwendig ist
  4. Die Falle des vorzeitigen Async
  5. Entscheidungsbaum
  6. Kernaussagen

Die Wahl ist nicht immer offensichtlich

Async ist nicht automatisch überlegen gegenüber Sync. Jeder Ansatz hat Kontexte, in denen er excelle, und die falsche Wahl kann Ihren Code komplizierter machen, ohne Leistungsgewinne zu erzielen. Diese Lektion hilft Ihnen zu entscheiden, welchen Ansatz Sie für Ihre Situation übernehmen sollten.

Wann Sync ausreicht

Der Sync-Client ist häufiger die richtige Wahl, als man vielleicht denkt, und der Grund ist immer derselbe: Wenn Parallelisierung nichts hinzufügt, ist ihre Komplexität ein Netto-Nachteil. Ein einmaliges Test- oder Erkundungsskript, das nur wenige Anfragen sendet, gewinnt nichts durch Async – Codeeinfachheit steht an erster Stelle, und Sie werden dieses Skript in sechs Monaten erneut lesen. Eine sequenzielle Pipeline, bei der jede Anfrage vom vorherigen Ergebnis abhängt, kann ohnehin nichts parallelisieren: Async würde Syntax hinzufügen, ohne die Ausführungszeit um eine Sekunde zu ändern. Dieselbe Logik gilt für eine traditionelle Django-Anwendung: Wenn Ihr Stack nicht async ist, die Erstellung einer Sync/Async-Grenze allein durch das Hinzufügen von asyncio für API-Aufrufe wartungsintensiv und schmerzhaft ist. Und in der Prototypierungsphase, wenn Sie einen Prompt testen oder ein Konzept validieren, ist Sync-Code schneller zu lesen und zu schreiben – genau das, was Sie von einem Prototyp erwarten.

# Sync — perfekt für eine sequenzielle Pipeline
from openai import OpenAI

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

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

# Schritt 2: Generierung einer Zusammenfassung basierend auf der 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 diesem Beispiel hängt Schritt 2 vom Ergebnis von Schritt 1 ab. Async bietet hier keinen Vorteil.

Wann Async notwendig ist

Async wird essenziell, sobald Netzwerklatenz die Ausführungszeit dominiert und die Anfragen unabhängig voneinander sind. Der Lehrbuchfall ist die Batch-Verarbeitung: Dutzende oder Hunderte von Anfragen ohne Abhängigkeiten zwischen ihnen, wobei der Gewinn proportional zum Volumen ist – hundert zweisekündige Anfragen benötigen in der Sequenz drei Minuten, bei kontrollierter Parallelisierung etwa zehn Sekunden. Der zweite Fall ist keine Wahl, sondern eine Anforderung: In einer FastAPI- oder Starlette-Anwendung ist das Framework bereits async, und die Verwendung eines Sync-Clients würde den Event-Loop blockieren – jeder Aufruf an Grok würde alle anderen Anfragen an Ihren Server einfrieren. Dann gibt es natürlich auch konkurrierende Architekturen: Ein Chatbot, der Grok, eine Datenbank und eine externe API parallel abfragt, um seine Antwort zu komponieren, oder ein Überwachungssystem, das mehrere Streams gleichzeitig beobachtet – Async ist dort einfach die natürliche Lösung für das Problem.

# Async — Verarbeitung von 50 Fragen parallel
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])

Mit 50 Fragen und einem Semaphore von 5 verarbeiten Sie 5 Anfragen parallel statt einer. Wenn jede Anfrage 8 Sekunden dauert, reduziert sich die Gesamtzeit von 400 Sekunden auf etwa 80 Sekunden.

Die Falle des vorzeitigen Async

Schlecht entworfener Async-Code ist schlechter als gut geschriebener Sync-Code. Hier sind häufige Fehler:

Blockierung des Event-Loops

# SCHLECHT: Sync-Aufruf in einer async-Funktion
async def bad_example():
    response = requests.get("https://api.example.com")  # blockiert alles
    return response.json()

Die Bibliothek requests ist sync. Der Aufruf in einem Coroutine blockiert den Event-Loop und negiert jeglichen Vorteil von Async. Verwenden Sie stattdessen httpx oder aiohttp.

Unnötige Komplexität

# SCHLECHT: Async für eine einzelne Anfrage
async def over_engineered():
    response = await client.chat.completions.create(...)
    return response

# Sync-Äquivalent, einfacher
def simple():
    response = client.chat.completions.create(...)
    return response

Wenn Sie nur eine Anfrage senden müssen, fügt Async Komplexität hinzu, ohne einen Vorteil zu bieten.

Entscheidungsbaum

Um zwischen Sync und Async zu wählen, stellen Sie sich diese Fragen in der folgenden Reihenfolge:

  1. Wie viele API-Anfragen senden Sie? Wenn eine oder wenige in der Sequenz, bleiben Sie bei Sync.
  2. Sind die Anfragen unabhängig? Wenn jede Anfrage von der vorherigen abhängt, bleiben Sie bei Sync.
  3. Ist Ihr Framework async? Wenn ja (FastAPI, Starlette, aiohttp), verwenden Sie Async, um den Event-Loop zu blockieren.
  4. Ist die Gesamtverarbeitungszeit ein Problem? Wenn Sie Batches verarbeiten und die Sync-Zeit inakzeptabel ist, wechseln Sie zu Async.

Kernaussagen

  • Sync funktioniert für einfache Skripte, sequenzielle Pipelines und Prototypen
  • Async ist notwendig für Batch-Verarbeitung, async-Frameworks und parallele Anfragen
  • Verwenden Sie niemals Sync-Bibliotheken (requests) in Async-Code
  • Durch Async hinzugefügte Komplexität muss durch messbare Gewinne gerechtfertigt sein
  • Beginnen Sie mit Sync und migrieren Sie zu Async, wenn der Bedarf bestätigt ist