Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Szemafórok használata a párhuzamos kérések korlátozására

4. lecke 12 közül Frissítve 2026. július 30. Haladó
Ezen az oldalon
  1. A kontrollálatlan konkurencia problémái
  2. Hogyan működnek a szemafórok
  3. Teljes minta az OpenAI SDK-val
  4. A megfelelő szemafór-érték kiválasztása
  5. Gyakori hiba: globális vs. lokális szemafór
  6. Főbb megállapítások

A kontrollálatlan konkurencia problémái

Gyakori hiba, ha korlátozás nélkül indítasz el minden kérést párhuzamosan. Ha 200 kérdést kell feldolgoznod, és egyszerre indítod el őket, akkor elérheted az API sebességkorlátait, HTTP 429-es hibákat kapsz, és ideiglenesen letilthatják az API-kulcsodat is.

A szemafór a szabványos megoldás a párhuzamos kérések számának vezérlésére. Ez egy számláló, amely meghatározza, hogy maximum hány korutin fusson egyszerre.

5
Ajánlott párhuzamos kérések
429
HTTP sebességkorlát hiba
RPM
Kérések percenként
TPM
Tokenek percenként

Hogyan működnek a szemafórok

Az asyncio.Semaphore számláló zárként működik. Amikor egy korutin belép az async with semaphore blokkba, a számláló értéke csökken. Kilépéskor nő. Ha a számláló eléri a nullát, a következő korutinok várakoznak, amíg felszabadul egy hely.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maximum 5 egyidejű kérés

async def process_request(request: str):
    async with semaphore:
        # Ez a szakasz maximum 5 párhuzamos végrehajtásra korlátozott
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

Ebben a példában, még ha 100 korutint is indítasz az asyncio.gather segítségével, egyszerre csak 5 fog futni. A maradék 95 vár a sorára.

Teljes minta az OpenAI SDK-val

Íme ugyanaz a minta az AsyncOpenAI használatával, amelyet gyakran preferálnak a kompatibilitás miatt:

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)

A max_concurrent paraméter konfigurálható. Állítsd be a sebességkorlátjaid alapján (7. lecke).

A megfelelő szemafór-érték kiválasztása

Számold ki az optimális értéket a sebességkorlátjaid alapján, de nem közvetlenül: figyelembe kell venned a kérések időtartamát is. Ha a csomagod 60 RPM-et engedélyez, és minden kérés kb. 10 másodpercig tart, akkor egy 5-ös szemafór legfeljebb 5 egyidejű kérést eredményez, ami percenként körülbelül 30 kérést jelent – ez kényelmesen a korlát alatt van. Alkalmazd ezt a logikát (RPM korlát × átlagos időtartam ÷ 60) a saját esetedre is. Ez magyarázza, miért igényelnek alacsonyabb szemafór-értéket a következtető modellek: a kéréseik tovább tartanak, így azonos konkurencia mellett csökken a percenkénti átvitel, és nő a pillanatnyi telítődés kockázata. Ha bizonytalan vagy, a legbiztonságosabb az empirikus megközelítés: kezdj alacsonyan, 3 és 5 között, figyeld a 429-es hibák arányát, és fokozatosan növeld az értéket, amíg megtalálod az egyensúlyt az átvitel és a stabilitás között.

Becslő számítás

Kérések percenként = szemafór * (60 / átlagos_időtartam_másodpercben)

Példa: szemafór=5, időtartam=10s → 5 * (60/10) = 30 RPM
Példa: szemafór=10, időtartam=5s → 10 * (60/5) = 120 RPM

Gyakori hiba: globális vs. lokális szemafór

# ROSSZ: új szemafór minden híváskor
async def bad_request(request: str):
    sem = Semaphore(5)  # minden hívás saját szemafórt hoz létre
    async with sem:
        return await client.chat.completions.create(...)

# JÓ: minden hívás között megosztott szemafór
sem = Semaphore(5)

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

A szemafórnak megosztottnak kell lennie az összes korutin között. Ha minden függvényen belül lokálisan hozod létre, akkor minden korutinnak saját szemafóra lesz, és a korlátozás nem fog működni.

Főbb megállapítások

  • A szemafór korlátozza az egyidejű API-kérések számát a sebességkorlátok betartása érdekében
  • Használd az async with semaphore szerkezetet az API-hívások védelmére
  • Kezdj 3 és 5 közötti értékkel, és az RPM-korlátjaid alapján állítsd be
  • A szemafórnak megosztottnak kell lennie (globális vagy paraméterként átadott), soha ne hozd létre lokálisan
  • Az RPM = szemafór * (60 / átlagos_időtartam) képlet segít a megfelelő érték meghatározásában