Uporaba semaforjev za omejitev sočasnih zahtevkov
Na tej strani
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.
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 semaphoreza 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