Semaforen gebruiken om gelijktijdige verzoeken te beperken
Op deze pagina
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.
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 semaphoreom 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