Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Använda semaforer för att begränsa samtidiga förfrågningar

Lektion 4 av 12 Uppdaterad 30 juli 2026 Avancerad
På denna sida
  1. Problemet med okontrollerad samtidighet
  2. Hur semaforer fungerar
  3. Komplett mönster med OpenAI SDK
  4. Att välja rätt semaforvärde
  5. Vanligt misstag: global kontra lokal semafor
  6. Viktiga punkter

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.

5
Rekommenderade parallella förfrågningar
429
HTTP-fel för hastighetsbegränsning
RPM
Förfrågningar per minut
TPM
Tokens per minut

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 semaphore fö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