Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Uporaba semaforjev za omejitev sočasnih zahtevkov

Lekcija 4 od 12 Posodobljeno 30. julij 2026 Napredni
Na tej strani
  1. Težava z nenadzorovano sočasnostjo
  2. Kako delujejo semaforji
  3. Celoten vzorec z OpenAI SDK
  4. Izbira prave vrednosti semaforja
  5. Pogosta napaka: globalni proti lokalnemu semaforju
  6. Ključne ugotovitve

Težava z nenadzorovano sočasnostjo

Pošiljanje vseh zahtevkov vzporedno brez omejitev je pogosta napaka. Če imaš 200 vprašanj za obdelavo in jih zaženeš vse hkrati, boš dosegel omejitve hitrosti API-ja, prejel napake HTTP 429 in potencialno začasno blokiral svoj ključ API.

Semafor je standardna rešitev za nadzor števila sočasnih zahtevkov. Deluje kot števec, ki omogoča največje število korutin, ki se lahko izvajajo vzporedno.

5
Priporočeni vzporedni zahtevki
429
Napaka omejitve hitrosti HTTP
RPM
Zahtevkov na minuto
TPM
Žetonov na minuto

Kako delujejo semaforji

asyncio.Semaphore deluje kot zaklep s števcem. Ko korotina vstopi v blok async with semaphore, se števec zmanjša. Ko izstopi, se števec poveča. Če števec doseže nič, naslednje korutine čakajo, dokler se ne sprosti mesto.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # največ 5 sočasnih zahtevkov

async def process_request(request: str):
    async with semaphore:
        # Ta del je omejen na 5 vzporednih izvedb
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

V tem primeru, tudi če zaženeš 100 korutin z asyncio.gather, jih bo hkrati teklo le 5. Ostalih 95 bo počakalo na svojo vrsto.

Celoten vzorec z OpenAI SDK

Tukaj je isti vzorec z uporabo AsyncOpenAI, ki je pogosto prednostna izbira zaradi združljivosti:

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)

Parameter max_concurrent je mogoče konfigurirati. Nastavi ga glede na svoje omejitve hitrosti (lekcija 7).

Izbira prave vrednosti semaforja

Izračunaj optimalno vrednost na podlagi svojih omejitev hitrosti, vendar ne neposredno: upoštevati moraš trajanje zahtevka. Če tvoja raven omogoča 60 RPM in vsak zahtevek traja približno 10 sekund, bo semafor z vrednostjo 5 proizvedel največ 5 sočasnih zahtevkov, kar je približno 30 zahtevkov na minuto – kar je varno pod omejitvijo. To razmišljanje (omejitev RPM × povprečno trajanje ÷ 60) uporabi za svoj primer. To pojasnjuje, zakaj modeli za sklepanje zahtevajo nižji semafor: njihovi zahtevki trajajo dlje, zato pri enaki sočasnosti pretočnost na minuto pade in tveganje za trenutno zasičenost naraste. Ko si v dvomih, je empirični pristop najvarnejši: začni nizko, med 3 in 5, opazuj stopnjo napak 429 in postopoma povečuj, dokler ne najdeš ravnovesja med pretočnostjo in stabilnostjo.

Približen izračun

Zahtevkov na minuto = semafor * (60 / povprečno_trajanje_v_sekundah)

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

Pogosta napaka: globalni proti lokalnemu semaforju

# SLABO: nov semafor ob vsakem klicu
async def bad_request(request: str):
    sem = Semaphore(5)  # vsak klic ustvari svoj semafor
    async with sem:
        return await client.chat.completions.create(...)

# DOBRO: semafor deljen med vse klice
sem = Semaphore(5)

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

Semafor mora biti deljen med vsemi korutinami. Če ga ustvariš lokalno znotraj vsake funkcije, bo imela vsaka korutina svoj semafor in omejitev ne bo delovala.

Ključne ugotovitve

  • Semafor omejuje število sočasnih zahtevkov API-ja za spoštovanje omejitev hitrosti
  • Uporabi async with semaphore za zaščito klicev API-ja
  • Začni z vrednostjo med 3 in 5 ter prilagajaj glede na svoje omejitve RPM
  • Semafor mora biti deljen (globalen ali podan kot parameter), nikoli ustvarjen lokalno
  • Formula RPM = semafor * (60 / povprečno_trajanje) pomaga določiti pravilno vrednost