Använda semaforer för att begränsa samtidiga förfrågningar
På denna sida
Problemet med okontrollerad samtidighet
Att skicka iväg alla dina förfrågningar parallellt utan begränsningar är ett vanligt misstag. Om du har 200 frågor att bearbeta och startar dem alla samtidigt kommer du att träffa API-begränsningar, få HTTP 429-fel och potentiellt bli tillfälligt blockerad från din API-nyckel.
En semafor är standardlösningen för att styra antalet samtidiga förfrågningar. Det är en räknare som tillåter ett maximalt antal korutiner att köras parallellt.
Hur semaforer fungerar
asyncio.Semaphore fungerar som ett räknarlås. När en korutin går in i blocket async with semaphore minskar räknaren. När den lämnar blocket ökar räknaren. Om räknaren når noll väntar efterföljande korutiner tills en plats blir ledig.
import asyncio
from asyncio import Semaphore
semaphore = Semaphore(5) # maximalt 5 samtidiga förfrågningar
async def process_request(request: str):
async with semaphore:
# Denna sektion är begränsad till 5 parallella körningar
chat = client.chat.create(
model="grok-4.20-0309-reasoning",
max_tokens=100
)
chat.append(user(request))
return await chat.sample()
I detta exempel, även om du startar 100 korutiner med asyncio.gather, kommer endast 5 att köras samtidigt. De andra 95 väntar på sin tur.
Komplett mönster med OpenAI SDK
Här är samma mönster med AsyncOpenAI, vilket ofta föredras för kompatibilitet:
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)
Parametern max_concurrent är konfigurerbar. Ställ in den baserat på dina hastighetsbegränsningar (lektion 7).
Att välja rätt semaforvärde
Beräkna det optimala värdet från dina hastighetsbegränsningar, men inte direkt: du måste ta hänsyn till förfrågningarnas varaktighet. Om din nivå tillåter 60 RPM och varje förfrågan tar cirka 10 sekunder, ger en semafor på 5 som mest 5 samtidiga förfrågningar, eller cirka 30 förfrågningar per minut – vilket ligger bekvämt under gränsen. Tillämpa detta resonemang (RPM-gräns × genomsnittlig varaktighet ÷ 60) på ditt eget fall. Det förklarar varför resonemangsmodeller kräver en lägre semafor: deras förfrågningar tar längre tid, så vid lika samtidighet sjunker genomströmningen per minut och risken för tillfällig mättnad ökar. Vid tvekan är den empiriska metoden säkrast: börja lågt, mellan 3 och 5, observera frekvensen av 429-fel och öka gradvis tills du hittar balansen mellan genomströmning och stabilitet.
Ungefärlig beräkning
Förfrågningar per minut = semafor * (60 / genomsnittlig_varaktighet_sekunder)
Exempel: semafor=5, varaktighet=10s → 5 * (60/10) = 30 RPM
Exempel: semafor=10, varaktighet=5s → 10 * (60/5) = 120 RPM
Vanligt misstag: global kontra lokal semafor
# DÅLIGT: ny semafor vid varje anrop
async def bad_request(request: str):
sem = Semaphore(5) # varje anrop skapar sin egen semafor
async with sem:
return await client.chat.completions.create(...)
# BRA: semafor delas över alla anrop
sem = Semaphore(5)
async def good_request(request: str):
async with sem:
return await client.chat.completions.create(...)
Semaforen måste delas mellan alla korutiner. Om du skapar den lokalt inuti varje funktion kommer varje korutin att ha sin egen semafor och begränsningen kommer inte att fungera.
Viktiga punkter
- En semafor begränsar antalet samtidiga API-förfrågningar för att respektera hastighetsbegränsningar
- Använd
async with semaphoreför att skydda API-anrop - Börja med ett värde mellan 3 och 5 och justera baserat på dina RPM-gränser
- Semaforen måste delas (global eller skickas som parameter), aldrig skapas lokalt
- Formeln
RPM = semafor * (60 / genomsnittlig_varaktighet)hjälper till att dimensionera värdet