Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Brug af semaforer til at begrænse samtidige anmodninger

Lektion 4 af 12 Opdateret 30. juli 2026 Avanceret
På denne side
  1. Problemet med ukontrolleret samtidighed
  2. Hvordan semaforer fungerer
  3. Komplet mønster med OpenAI SDK
  4. Valg af den rette semafor-værdi
  5. Almindelig fejl: global kontra lokal semafor
  6. Vigtige pointer

Problemet med ukontrolleret samtidighed

Det er en almindelig fejl at fyre alle dine anmodninger af parallelt uden begrænsninger. Hvis du har 200 spørgsmål, der skal behandles, og lancerer dem alle samtidigt, vil du ramme API-rategrænser, modtage HTTP 429-fejl og potentielt få din API-nøgle midlertidigt blokeret.

En semafor er standardløsningen til at kontrollere antallet af samtidige anmodninger. Det er en tæller, der tillader et maksimalt antal coroutines at køre parallelt.

5
Anbefalede parallelle anmodninger
429
HTTP rate limit-fejl
RPM
Anmodninger per minut
TPM
Tokens per minut

Hvordan semaforer fungerer

asyncio.Semaphore fungerer som en tællerlås. Når en coroutine entrer blokken async with semaphore, falder tælleren. Når den forlader blokken, stiger tælleren. Hvis tælleren rammer nul, venter efterfølgende coroutines, indtil en plads bliver ledig.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maksimalt 5 samtidige anmodninger

async def process_request(request: str):
    async with semaphore:
        # Dette afsnit er begrænset til 5 parallelle eksekveringer
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

I dette eksempel vil kun 5 coroutines køre samtidigt, selvom du lancerer 100 med asyncio.gather. De øvrige 95 vil vente på deres tur.

Komplet mønster med OpenAI SDK

Her er det samme mønster implementeret med AsyncOpenAI, som ofte foretrækkes af kompatibilitetsårsager:

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)

Parameteren max_concurrent er konfigurerbar. Indstil den baseret på dine rategrænser (lektion 7).

Valg af den rette semafor-værdi

Beregn den optimale værdi ud fra dine rategrænser, men ikke direkte: du skal tage højde for anmodningens varighed. Hvis dit niveau tillader 60 RPM, og hver anmodning tager ca. 10 sekunder, vil en semafor på 5 resultere i maksimalt 5 samtidige anmodninger, eller omkring 30 anmodninger per minut – hvilket ligger komfortabelt under grænsen. Anvend denne logik (RPM-grænse × gennemsnitlig varighed ÷ 60) på dit eget tilfælde. Det forklarer, hvorfor ræsonnementsmodeller kræver en lavere semafor-værdi: deres anmodninger tager længere tid, så ved samme samtidighed falder gennemstrømningen per minut, og risikoen for øjeblikkelig mætning stiger. Hvis du er i tvivl, er den empiriske tilgang sikrest: start lavt, mellem 3 og 5, observer hyppigheden af 429-fejl, og øg gradvist, indtil du finder balancen mellem gennemstrømning og stabilitet.

Omtrentlig beregning

Anmodninger per minut = semafor * (60 / gennemsnitlig_varighed_i_sekunder)

Eksempel: semafor=5, varighed=10s → 5 * (60/10) = 30 RPM
Eksempel: semafor=10, varighed=5s → 10 * (60/5) = 120 RPM

Almindelig fejl: global kontra lokal semafor

# DÅRLIGT: ny semafor ved hvert kald
async def bad_request(request: str):
    sem = Semaphore(5)  # hvert kald opretter sin egen semafor
    async with sem:
        return await client.chat.completions.create(...)

# GODT: semafor deles på tværs af alle kald
sem = Semaphore(5)

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

Semaforen skal deles på tværs af alle coroutines. Hvis du opretter den lokalt inde i hver funktion, vil hver coroutine have sin egen semafor, og begrænsningen vil ikke virke.

Vigtige pointer

  • En semafor begrænser antallet af samtidige API-anmodninger for at overholde rategrænser
  • Brug async with semaphore til at beskytte API-kald
  • Start med en værdi på 3 til 5 og juster baseret på dine RPM-grænser
  • Semaforen skal deles (global eller sendes som parameter), aldrig oprettes lokalt
  • Formlen RPM = semafor * (60 / gennemsnitlig_varighed) hjælper med at dimensionere værdien