Salt la conținutul principal
Română— Alege o limbă
Meniu

Utilizarea semafoarelor pentru limitarea cererilor concurente

Lecția 4 din 12 Actualizată 30 iulie 2026 Avansat
Pe această pagină
  1. Problema concurenței necontrolate
  2. Cum funcționează semafoarele
  3. Model complet cu SDK-ul OpenAI
  4. Alegerea valorii corecte pentru semafor
  5. Greșeală frecventă: semafor global vs. local
  6. Puncte cheie

Problema concurenței necontrolate

Lansarea tuturor cererilor dumneavoastră în paralel, fără limite, este o greșeală frecventă. Dacă aveți 200 de întrebări de procesat și le lansați simultan pe toate, veți atinge limitele de rată ale API-ului, veți primi erori HTTP 429 și riscați blocarea temporară a cheii dumneavoastră API.

Un semafor este soluția standard pentru controlul numărului de cereri concurente. Acesta funcționează ca un contor care permite unui număr maxim de corutine să ruleze în paralel.

5
Număr recomandat de cereri paralele
429
Eroare de limitare a ratei HTTP
RPM
Cereri pe minut
TPM
Tokeni pe minut

Cum funcționează semafoarele

asyncio.Semaphore acționează ca un mecanism de blocare bazat pe contor. Când o corutină intră în blocul async with semaphore, contorul scade. Când iese din bloc, contorul crește. Dacă contorul ajunge la zero, corutinele ulterioare așteaptă până se eliberează un slot.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maximum 5 cereri simultane

async def process_request(request: str):
    async with semaphore:
        # Această secțiune este limitată la 5 execuții paralele
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

În acest exemplu, chiar dacă lansați 100 de corutine cu asyncio.gather, doar 5 vor rula simultan. Celelalte 95 vor aștepta la rând.

Model complet cu SDK-ul OpenAI

Iată același model utilizând AsyncOpenAI, care este adesea preferat pentru compatibilitate:

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)

Parametrul max_concurrent este configurabil. Stabiliți-l în funcție de limitele dumneavoastră de rată (lecția 7).

Alegerea valorii corecte pentru semafor

Calculați valoarea optimă pe baza limitelor de rată, dar nu direct: trebuie să luați în calcul durata cererii. Dacă nivelul dumneavoastră permite 60 RPM și fiecare cerere durează aproximativ 10 secunde, un semafor de 5 produce cel mult 5 cereri simultane, adică aproximativ 30 de cereri pe minut – confortabil sub limită. Aplicați acest raționament (limita RPM × durata medie ÷ 60) propriului caz. Acest lucru explică de ce modelele de raționament necesită un semafor mai mic: cererile lor durează mai mult, astfel încât, la o concurență egală, debitul pe minut scade, iar riscul de saturație momentană crește. În caz de îndoială, abordarea empirică este cea mai sigură: începeți cu o valoare mică, între 3 și 5, observați rata erorilor 429 și creșteți treptat până găsiți echilibrul între debit și stabilitate.

Calcul aproximativ

Cereri pe minut = semafor * (60 / durata_medie_secunde)

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

Greșeală frecventă: semafor global vs. local

# RĂU: semafor nou la fiecare apel
async def bad_request(request: str):
    sem = Semaphore(5)  # fiecare apel creează propriul semafor
    async with sem:
        return await client.chat.completions.create(...)

# BINE: semafor partajat între toate apelurile
sem = Semaphore(5)

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

Semaforul trebuie partajat între toate corutinele. Dacă îl creați local în interiorul fiecărei funcții, fiecare corutină va avea propriul semafor, iar limita nu va funcționa.

Puncte cheie

  • Un semafor limitează numărul de cereri API simultane pentru a respecta limitele de rată
  • Utilizați async with semaphore pentru a proteja apelurile API
  • Începeți cu o valoare între 3 și 5 și ajustați în funcție de limitele dumneavoastră RPM
  • Semaforul trebuie să fie partajat (global sau transmis ca parametru), niciodată creat local
  • Formula RPM = semafor * (60 / durata_medie) ajută la dimensionarea valorii