Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Obmedzenie súbežných požiadaviek pomocou semaforov

Lekcia 4 z 12 Aktualizované 30. júla 2026 Pokročilý
Na tejto strane
  1. Problém nekontrolovanej súbežnosti
  2. Ako fungujú semafory
  3. Kompletný vzor so SDK OpenAI
  4. Výber správnej hodnoty semafora
  5. Častá chyba: globálny versus lokálny semafor
  6. Kľúčové poznatky

Problém nekontrolovanej súbežnosti

Spustenie všetkých požiadaviek naraz bez obmedzení je častá chyba. Ak máš spracovať 200 otázok a spustíš ich všetky súčasne, narazíš na limity rýchlosti API, dostaneš chyby HTTP 429 a tvoj API kľúč môže byť dočasne zablokovaný.

Semafor je štandardným riešením na kontrolu počtu súbežných požiadaviek. Funguje ako počítadlo, ktoré umožňuje spustiť paralelne maximálny stanovený počet korutín.

5
Odporúčaný počet paralelných požiadaviek
429
Chyba limitu rýchlosti HTTP
RPM
Požiadaviek za minútu
TPM
Tokenov za minútu

Ako fungujú semafory

asyncio.Semaphore funguje ako zámok s počítadlom. Keď korutína vstúpi do bloku async with semaphore, hodnota počítadla sa zníži. Pri jej ukončení sa hodnota zvýši. Ak počítadlo dosiahne nulu, ďalšie korutíny čakajú, kým sa neuvolní miesto.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maximálne 5 súčasných požiadaviek

async def process_request(request: str):
    async with semaphore:
        # Táto časť je obmedzená na 5 paralelných vykonaní
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

V tomto príklade, aj keď spustíš 100 korutín pomocou asyncio.gather, súčasne bežia iba 4. Ostatných 95 čaká na svoj ťah.

Kompletný vzor so SDK OpenAI

Tu je rovnaký vzor použitý s AsyncOpenAI, čo sa často preferuje kvôli kompatibilite:

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 konfigurovateľný. Nastav ho podľa svojich limitov rýchlosti (lekcia 7).

Výber správnej hodnoty semafora

Vypočítaj optimálnu hodnotu na základe svojich limitov rýchlosti, ale nie priamo: musíš zohľadniť trvanie požiadavky. Ak tvoja úroveň umožňuje 60 RPM a každá požiadavka trvá približne 10 sekúnd, semafor s hodnotou 5 vytvorí maximálne 5 súčasných požiadaviek, čo je asi 30 požiadaviek za minútu – bezpečne pod limitom. Aplikuj túto úvahu (limit RPM × priemerné trvanie ÷ 60) na svoj vlastný prípad. Vysvetľuje to, prečo modely na logické usudzovanie vyžadujú nižšiu hodnotu semafora: ich požiadavky trvajú dlhšie, takže pri rovnakej súbežnosti klesá priepustnosť za minútu a zvyšuje sa riziko momentálneho preťaženia. Ak si nie si istý, najbezpečnejší je empirický prístup: začni nízko, medzi 3 a 5, sleduj mieru chýb 429 a postupne zvyšuj hodnotu, kým nenájdeš rovnováhu medzi priepustnosťou a stabilitou.

Približný výpočet

Požiadaviek za minútu = semafor * (60 / priemerné_trvanie_v_sekundách)

Príklad: semafor=5, trvanie=10s → 5 * (60/10) = 30 RPM
Príklad: semafor=10, trvanie=5s → 10 * (60/5) = 120 RPM

Častá chyba: globálny versus lokálny semafor

# ZLE: nový semafor pri každom volaní
async def bad_request(request: str):
    sem = Semaphore(5)  # každé volanie vytvorí vlastný semafor
    async with sem:
        return await client.chat.completions.create(...)

# DOBRE: semafor zdieľaný medzi všetkými volaniami
sem = Semaphore(5)

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

Semafor musí byť zdieľaný medzi všetkými korutínami. Ak ho vytvoríš lokálne vo vnútri každej funkcie, každá korutína bude mať vlastný semafor a obmedzenie nebude fungovať.

Kľúčové poznatky

  • Semafor obmedzuje počet súčasných požiadaviek API, aby sa dodržali limity rýchlosti
  • Na ochranu volaní API použi async with semaphore
  • Začni s hodnotou 3 až 5 a upravuj ju podľa svojich limitov RPM
  • Semafor musí byť zdieľaný (globálny alebo odovzdaný ako parameter), nikdy ho nevytváraj lokálne
  • Vzorec RPM = semafor * (60 / priemerné_trvanie) pomáha určiť správnu veľkosť hodnoty