Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Semaforen gebruiken om gelijktijdige verzoeken te beperken

Les 4 van 12 Bijgewerkt op 30 juli 2026 Gevorderd
Op deze pagina
  1. Het probleem met ongecontroleerde gelijktijdigheid
  2. Hoe semaforen werken
  3. Volledig patroon met de OpenAI SDK
  4. De juiste semafoorwaarde kiezen
  5. Veelgemaakte fout: globale versus lokale semafoor
  6. Belangrijkste punten

Het probleem met ongecontroleerde gelijktijdigheid

Het zonder beperkingen parallel afvuren van al uw verzoeken is een veelgemaakte fout. Als u 200 vragen moet verwerken en deze allemaal tegelijk start, loopt u tegen API-rate-limits aan, ontvangt u HTTP 429-fouten en wordt uw API-sleutel mogelijk tijdelijk geblokkeerd.

Een semafoor is de standaardoplossing om het aantal gelijktijdige verzoeken te regelen. Het is een teller die een maximaal aantal coroutines toestaat om parallel te draaien.

5
Aanbevolen parallelle verzoeken
429
HTTP rate limit-fout
RPM
Verzoeken per minuut
TPM
Tokens per minuut

Hoe semaforen werken

asyncio.Semaphore fungeert als een tellerslot. Wanneer een coroutine het blok async with semaphore binnenkomt, daalt de teller. Bij het verlaten stijgt de teller weer. Als de teller nul bereikt, wachten volgende coroutines tot er een plek vrijkomt.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maximaal 5 gelijktijdige verzoeken

async def process_request(request: str):
    async with semaphore:
        # Dit gedeelte is beperkt tot 5 parallelle uitvoeringen
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

In dit voorbeeld worden er, zelfs als u 100 coroutines start met asyncio.gather, slechts 5 tegelijkertijd uitgevoerd. De andere 95 wachten op hun beurt.

Volledig patroon met de OpenAI SDK

Hier ziet u hetzelfde patroon met AsyncOpenAI, wat vaak de voorkeur heeft vanwege de compatibiliteit:

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 send_request(sem: Semaphore, request: str) -> dict:
    async with sem:
        return await client.chat.completions.create(
            model="grok-4.20-0309-reasoning",
            messages=[{"role": "user", "content": request}]
        )

async def process_all(requests: list[str], max_concurrent: int = 5):
    sem = Semaphore(max_concurrent)
    tasks = [send_request(sem, r) for r in requests]
    return await asyncio.gather(*tasks)

De parameter max_concurrent is configureerbaar. Stel deze in op basis van uw rate limits (les 7).

De juiste semafoorwaarde kiezen

Bereken de optimale waarde op basis van uw rate limits, maar niet direct: u houdt rekening met de duur van het verzoek. Als uw tier 60 RPM toestaat en elk verzoek ongeveer 10 seconden duurt, levert een semafoor van 5 maximaal 5 gelijktijdige verzoeken op, oftewel ongeveer 30 verzoeken per minuut. Dit blijft ruim onder de limiet. Pas deze redenering (RPM-limiet × gemiddelde duur ÷ 60) toe op uw eigen situatie. Dit verklaart waarom redeneermodellen een lagere semafoorwaarde vereisen: hun verzoeken duren langer, waardoor bij gelijke gelijktijdigheid de doorvoer per minuut daalt en het risico op momentele overbelasting toeneemt. Bij twijfel is de empirische aanpak het veiligst: begin laag, tussen 3 en 5, observeer het percentage 429-fouten en voer de waarde geleidelijk op tot u de balans tussen doorvoer en stabiliteit heeft gevonden.

Geschatte berekening

Verzoeken per minuut = semafoor * (60 / gemiddelde_duur_seconden)

Voorbeeld: semafoor=5, duur=10s → 5 * (60/10) = 30 RPM
Voorbeeld: semafoor=10, duur=5s → 10 * (60/5) = 120 RPM

Veelgemaakte fout: globale versus lokale semafoor

# SLECHT: bij elke aanroep een nieuwe semafoor
async def bad_request(request: str):
    sem = Semaphore(5)  # elke aanroep maakt zijn eigen semafoor
    async with sem:
        return await client.chat.completions.create(...)

# GOED: semafoor gedeeld over alle aanroepen
sem = Semaphore(5)

async def good_request(request: str):
    async with sem:
        return await client.chat.completions.create(...)

De semafoor moet gedeeld worden door alle coroutines. Als u deze lokaal binnen elke functie aanmaakt, heeft elke coroutine zijn eigen semafoor en werkt de limiet niet.

Belangrijkste punten

  • Een semafoor beperkt het aantal gelijktijdige API-verzoeken om rate limits te respecteren
  • Gebruik async with semaphore om API-aanroepen te beschermen
  • Begin met een waarde tussen 3 en 5 en pas deze aan op basis van uw RPM-limieten
  • De semafoor moet gedeeld zijn (globaal of als parameter doorgegeven), maak deze nooit lokaal aan
  • De formule RPM = semafoor * (60 / gemiddelde_duur) helpt bij het bepalen van de waarde