Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

L-użu tas-Semaphores biex Tillimita Talbiet Konkorrenti

Lezzjoni 4 / 12 Aġġornat 30 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Il-problema tal-konkorrenza mingħajr kontroll
  2. Kif jaħdmu s-Semaphores
  3. Mudell sħiħ bl-SDK ta’ OpenAI
  4. Għażla tal-valur tas-semaphore t-tajjeb
  5. Żball komuni: semaphore globali vs lokali
  6. Punti Ewlenin

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.

5
Recommended parallel requests
429
HTTP rate limit error
RPM
Requests per minute
TPM
Tokens per minute

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 semaphore biex 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