Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Korištenje semafora za ograničavanje istodobnih zahtjeva

Lekcija 4 od 12 Ažurirano 30. srpnja 2026. Napredno
Na ovoj stranici
  1. Problem nekontrolirane konkurentnosti
  2. Kako semafori rade
  3. Potpuni uzorak s OpenAI SDK-jem
  4. Odabir ispravne vrijednosti semafora
  5. Česta greška: globalni naspram lokalnog semafora
  6. Ključne točke

Problem nekontrolirane konkurentnosti

Pokretanje svih zahtjeva paralelno bez ograničenja česta je greška. Ako imaš 200 pitanja za obradu i pokreneš ih sve odjednom, udarit ćeš u ograničenja stope (rate limits) API-ja, primiti HTTP 429 pogreške i potencijalno dobiti privremeno blokiran API ključ.

Semafor je standardno rješenje za kontrolu broja istodobnih zahtjeva. To je brojač koji dopušta maksimalan broj korutina da se izvršavaju paralelno.

5
Preporučeni paralelni zahtjevi
429
HTTP pogreška ograničenja stope
RPM
Zahtjeva po minuti
TPM
Tokena po minuti

Kako semafori rade

asyncio.Semaphore djeluje kao zaključani brojač. Kada korutina uđe u blok async with semaphore, brojač se smanjuje. Kada izađe, brojač se povećava. Ako brojač dođe do nule, naredne korutine čekaju dok se ne oslobodi mjesto.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maksimalno 5 istodobnih zahtjeva

async def process_request(request: str):
    async with semaphore:
        # Ovaj je dio ograničen na 5 paralelnih izvršavanja
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

U ovom primjeru, čak i ako pokreneš 100 korutina s asyncio.gather, samo će ih 5 raditi istovremeno. Ostalih 95 čekati će svoj red.

Potpuni uzorak s OpenAI SDK-jem

Evo istog uzorka koristeći AsyncOpenAI, koji se često preferira zbog kompatibilnosti:

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)

Parametar max_concurrent je podesiv. Postavi ga na temelju svojih ograničenja stope (lekcija 7).

Odabir ispravne vrijednosti semafora

Izračunaj optimalnu vrijednost iz svojih ograničenja stope, ali ne izravno: moraš uzeti u obzir trajanje zahtjeva. Ako tvoja razina dopušta 60 RPM, a svaki zahtjev traje oko 10 sekundi, semafor od 5 proizvodi najviše 5 istodobnih zahtjeva, odnosno oko 30 zahtjeva po minuti – što je sigurno ispod granice. Primijeni ovo razmišljanje (RPM ograničenje × prosječno trajanje ÷ 60) na svoj slučaj. To objašnjava zašto modeli za rezoniranje zahtijevaju niži semafor: njihovi zahtjevi traju duže, pa pri jednakoj konkurentnosti propusnost po minuti pada, a rizik od trenutnog zasićenja raste. Ako nisi siguran, empirijski pristup je najsigurniji: kreni nisko, između 3 i 5, promatraj stopu pogrešaka 429 i postupno povećavaj dok ne nađeš ravnotežu između propusnosti i stabilnosti.

Približni izračun

Zahtjeva po minuti = semafor * (60 / prosječno_trajanje_u_sekundama)

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

Česta greška: globalni naspram lokalnog semafora

# LOŠE: novi semafor pri svakom pozivu
async def bad_request(request: str):
    sem = Semaphore(5)  # svaki poziv stvara vlastiti semafor
    async with sem:
        return await client.chat.completions.create(...)

# DOBRO: semafor dijeljen između svih poziva
sem = Semaphore(5)

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

Semafor mora biti dijeljen između svih korutina. Ako ga stvoriš lokalno unutar svake funkcije, svaka će korutina imati vlastiti semafor i ograničenje neće raditi.

Ključne točke

  • Semafor ograničava broj istodobnih API zahtjeva kako bi se poštovala ograničenja stope
  • Koristi async with semaphore za zaštitu API poziva
  • Kreni s vrijednošću od 3 do 5 i prilagodi je na temelju svojih RPM ograničenja
  • Semafor mora biti dijeljen (globalan ili proslijeđen kao parametar), nikada stvoren lokalno
  • Formula RPM = semafor * (60 / prosječno_trajanje) pomaže u određivanju veličine vrijednosti