Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

asyncio.gather für die Batch-Verarbeitung

Lektion 5 von 12 Aktualisiert am 30. Juli 2026 Fortgeschritten
Auf dieser Seite
  1. Orchestrierung paralleler Anfragen
  2. Grundlegende Syntax
  3. Komplettes Muster: Batch mit Semaphore
  4. Fehlerbehandlung in einem Batch
  5. Aufteilung in Teilbatches (Chunking)
  6. Fortschrittsverfolgung
  7. Kernaussagen

Orchestrierung paralleler Anfragen

asyncio.gather ist die Kernfunktion zum parallelen Ausführen mehrerer Koroutinen und dem Sammeln aller Ergebnisse. In Kombination mit einem Semaphore ermöglicht es die effiziente Verarbeitung von Batch-Anfragen unter Einhaltung der API-Grenzen.

Grundlegende Syntax

import asyncio

requests = ["Frage 1", "Frage 2", "Frage 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)

asyncio.gather nimmt eine variable Anzahl von Koroutinen entgegen (daher das *tasks zum Entpacken der Liste) und gibt eine Liste von Ergebnissen zurück, die in derselben Reihenfolge wie die eingereichten Aufgaben stehen. Dies ist ein wichtiger Punkt: Selbst wenn Frage 3 vor Frage 1 fertig wird, enthält responses[0] immer das Ergebnis für Frage 1.

Komplettes Muster: Batch mit Semaphore

Dies ist das Muster, das Sie in der Produktion am häufigsten verwenden werden:

import os
from asyncio import Semaphore
from openai import AsyncOpenAI
import httpx

client = AsyncOpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://api.x.ai/v1",
    timeout=httpx.Timeout(3600.0)
)

async def process_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks)

Dieses Muster kapselt den Semaphore innerhalb der Batch-Funktion ein. Sie müssen lediglich process_batch(prompts) aufrufen und die Liste der Antworten abrufen.

Fehlerbehandlung in einem Batch

Standardmäßig führt asyncio.gather bei einer Ausnahme in einer einzelnen Koroutine dazu, dass alles abgebrochen wird und der Fehler propagiert wird. Der Parameter return_exceptions=True ändert dieses Verhalten:

async def safe_batch(prompts: list[str]) -> list[str | Exception]:
    sem = Semaphore(5)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Usage
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
    if isinstance(result, Exception):
        print(f"Fehler bei Prompt {i}: {result}")
    else:
        print(f"Ergebnis {i}: {result[:100]}...")

Mit return_exceptions=True werden Fehler als Werte in der Ergebnisliste erfasst. Sie können dann fehlgeschlagene Anfragen identifizieren und erneut versuchen.

Aufteilung in Teilbatches (Chunking)

Bei sehr großen Volumina ist es besser, in Teilbatches aufzuteilen, als tausende Aufgaben gleichzeitig zu starten:

async def chunked_batch(
    prompts: list[str],
    chunk_size: int = 50,
    max_concurrent: int = 5
) -> list[str]:
    all_results = []

    for i in range(0, len(prompts), chunk_size):
        chunk = prompts[i:i + chunk_size]
        print(f"Verarbeite Batch {i//chunk_size + 1} ({len(chunk)} Prompts)")
        results = await process_batch(chunk, max_concurrent)
        all_results.extend(results)

    return all_results

Chunking bietet mehrere Vorteile: Sie können den Fortschritt anzeigen, Zwischenergebnisse speichern und den Speicherverbrauch begrenzen. Wenn ein Teilbatch fehlschlägt, verlieren Sie nicht die Ergebnisse vorheriger Teilbatches.

Fortschrittsverfolgung

Bei großen Batches ist ein Fortschrittsanzeige nützlich:

import asyncio
from asyncio import Semaphore

async def batch_with_progress(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)
    completed = 0
    total = len(prompts)

    async def single_request(prompt: str) -> str:
        nonlocal completed
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            completed += 1
            print(f"\r{completed}/{total} abgeschlossen", end="", flush=True)
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    print()  # neue Zeile nach Fortschritt
    return results

Kernaussagen

  • asyncio.gather(*tasks) führt Koroutinen parallel aus und gibt Ergebnisse in der ursprünglichen Reihenfolge zurück
  • return_exceptions=True verhindert, dass ein einzelner Fehler den gesamten Batch versagt
  • Chunking ermöglicht die Handhabung sehr großer Volumina ohne Speicherüberlastung
  • Kombinieren Sie gather immer mit einem Semaphore, um Rate-Limits einzuhalten
  • Fügen Sie eine Fortschrittsverfolgung für langlaufende Prozesse hinzu