L-użu tas-Semaphores biex Tillimita Talbiet Konkorrenti
F'din il-paġna
Il-problema tal-konkorrenza mingħajr kontroll
Li tibgħat it-talbiet kollha tiegħek b’mod parallel mingħajr limiti huwa żball komuni. Jekk ikollok 200 mistoqsija biex tipproċessa u tniedihom kollha fl-istess ħin, se tilħaq il-limiti tar-rata tal-API, tirċievi żbalji HTTP 429, u potenzjalment tikseb il-key tal-API tiegħek imblukkat temporanjament.
Semaphore huwa s-soluzzjoni standard biex tikkontrolla n-numru ta’ talbiet konkorrenti. Huwa kontatur li jippermetti numru massimu ta’ coroutines li jiġu eżegwiti b’mod parallel.
Kif jaħdmu s-Semaphores
asyncio.Semaphore jaġixxi bħala lock tal-kontatur. Meta coroutine tidħol fil-blokka async with semaphore, il-kontatur jonqos. Meta toħroġ, il-kontatur jiżdied. Jekk il-kontatur jilħaq żero, is-coroutines sussegwenti jistennew sakemm jiftaħ slot.
import asyncio
from asyncio import Semaphore
semaphore = Semaphore(5) # maximum 5 simultaneous requests
async def process_request(request: str):
async with semaphore:
# This section is limited to 5 parallel executions
chat = client.chat.create(
model="grok-4.20-0309-reasoning",
max_tokens=100
)
chat.append(user(request))
return await chat.sample()
F’dan l-eżempju, anke jekk tniedi 100 coroutines b’asyncio.gather, biss 5 se jiġu eżegwiti fl-istess ħin. L-oħrajn 95 se jistennew id-dawra tagħhom.
Mudell sħiħ bl-SDK ta’ OpenAI
Hawnhekk hemm l-istess mudell bl-użu ta’ AsyncOpenAI, li spiss huwa ppreferut għall-kompatibbiltà:
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)
Il-parametru max_concurrent huwa konfigurabbli. Iffissah abbażi tal-limiti tar-rata tiegħek (lezzjoni 7).
Għażla tal-valur tas-semaphore t-tajjeb
Ikkalkula l-valur ottimali mil-limiti tar-rata tiegħek, iżda mhux direttament: trid tikkunsidra d-durata tat-talba. Jekk it-tier tiegħek jippermetti 60 RPM u kull talba tieħu madwar 10 sekondi, semaphore ta’ 5 jipproduċi massimu ta’ 5 talbiet simultanji, jew madwar 30 talba kull minuta—komdament taħt il-limitu. Applika dan ir-raġunament (limitu RPM × durata medja ÷ 60) għall-każ tiegħek stess. Dan jispjega għaliex il-mudelli tar-raġunament jeħtieġu semaphore aktar baxx: it-talbiet tagħhom jieħdu aktar żmien, allura f’konkorrenza ugwali, it-throughput kull minuta jonqos u r-riskju ta’ saturazzjoni momentanja jiżdied. Meta tkun f’dubju, l-approċċ empiriku huwa l-aktar sikur: ibda baxx, bejn 3 u 5, osserva r-rata ta’ żbalji 429, u żid gradwalment sakemm issib il-bilanċ bejn it-throughput u l-istabbiltà.
Kalkolu approssimattiv
Requests per minute = semaphore * (60 / average_duration_seconds)
Example: semaphore=5, duration=10s → 5 * (60/10) = 30 RPM
Example: semaphore=10, duration=5s → 10 * (60/5) = 120 RPM
Żball komuni: semaphore globali vs lokali
# BAD: new semaphore on every call
async def bad_request(request: str):
sem = Semaphore(5) # each call creates its own semaphore
async with sem:
return await client.chat.completions.create(...)
# GOOD: semaphore shared across all calls
sem = Semaphore(5)
async def good_request(request: str):
async with sem:
return await client.chat.completions.create(...)
Is-semaphore irid ikun kondiviż bejn il-coroutines kollha. Jekk toħloqu lokalment ġewwa kull funzjoni, kull coroutine ikollha s-semaphore tagħha stess u l-limitu ma jaħdimx.
Punti Ewlenin
- Semaphore jillimita n-numru ta’ talbiet simultanji tal-API biex jirrispetta l-limiti tar-rata
- Uża
async with semaphorebiex tipproteġi s-sejħiet tal-API - Ibda b’valur bejn 3 u 5 u aġusta abbażi tal-limiti RPM tiegħek
- Is-semaphore irid ikun kondiviż (globali jew mgħoddi bħala parametru), qatt maħluq lokalment
- Il-formula
RPM = semaphore * (60 / average_duration)tgħin biex tiddimensjona l-valur