Премини към основното съдържание
Български— Изберете език
Меню

Използване на семафори за ограничаване на едновременните заявки

Урок 4 от 12 Обновен 30 юли 2026 г. Напреднало
На тази страница
  1. Проблемът с неконтролираната конкурентност
  2. Как работят семафорите
  3. Пълен шаблон със SDK на OpenAI
  4. Избор на правилната стойност за семафора
  5. Честа грешка: глобален срещу локален семафор
  6. Ключови изводи

Проблемът с неконтролираната конкурентност

Изпращането на всички заявки паралелно без ограничения е честа грешка. Ако имате 200 въпроса за обработка и ги стартирате едновременно, ще достигнете лимитите на API, ще получите HTTP 429 грешки и потенциално ключът Ви за API може да бъде временно блокиран.

Семафорът е стандартното решение за контрол на броя едновременни заявки. Това е брояч, който позволява на максимален брой корутини да се изпълняват паралелно.

5
Препоръчителни паралелни заявки
429
HTTP грешка за лимит на честотата
RPM
Заявки в минута
TPM
Токъни в минута

Как работят семафорите

asyncio.Semaphore действа като брояч с ключалка. Когато корутина влезе в блока async with semaphore, броячът намалява. Когато излезе, броячът се увеличава. Ако броячът стигне до нула, следващите корутини изчакват, докато не се освободи място.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # максимум 5 едновременни заявки

async def process_request(request: str):
    async with semaphore:
        # Тази секция е ограничена до 5 паралелни изпълнения
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

В този пример, дори да стартирате 100 корутини с asyncio.gather, само 5 ще се изпълняват едновременно. Останалите 95 ще изчакват своя ред.

Пълен шаблон със SDK на OpenAI

Ето същия шаблон, използващ AsyncOpenAI, който често се предпочита заради съвместимостта:

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)

Параметърът max_concurrent е конфигурируем. Задайте го въз основа на Вашите лимити на честотата (урок 7).

Избор на правилната стойност за семафора

Изчислете оптималната стойност от Вашите лимити на честотата, но не директно: трябва да вземете предвид продължителността на заявката. Ако Вашият тарифен план позволява 60 RPM и всяка заявка отнема около 10 секунди, семафор със стойност 5 ще произведе най-много 5 едновременни заявки, или около 30 заявки в минута – комфортно под лимита. Приложете тази логика (лимит RPM × средна продължителност ÷ 60) към Вашия случай. Това обяснява защо моделите за разсъждение изискват по-нисък семафор: техните заявки отнемат повече време, така че при еднаква конкурентност пропускателната способност в минута намалява и рискът от моментално претоварване се увеличава. Когато се съмнявате, емпиричният подход е най-безопасен: започнете ниско, между 3 и 5, наблюдавайте честотата на грешките 429 и постепенно увеличавайте, докато намерите баланса между пропускателна способност и стабилност.

Приблизително изчисление

Заявки в минута = семафор * (60 / средна_продължителност_секунди)

Пример: семафор=5, продължителност=10с → 5 * (60/10) = 30 RPM
Пример: семафор=10, продължителност=5с → 10 * (60/5) = 120 RPM

Честа грешка: глобален срещу локален семафор

# ЛОШО: нов семафор при всяко извикване
async def bad_request(request: str):
    sem = Semaphore(5)  # всяко извикване създава свой собствен семафор
    async with sem:
        return await client.chat.completions.create(...)

# ДОБРЕ: семафор, споделен между всички извиквания
sem = Semaphore(5)

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

Семафорът трябва да бъде споделен между всички корутини. Ако го създадете локално във всяка функция, всяка корутина ще има свой собствен семафор и ограничението няма да работи.

Ключови изводи

  • Семафорът ограничава броя на едновременните API заявки, за да се спазват лимитите на честотата
  • Използвайте async with semaphore, за да защитите API извикванията
  • Започнете със стойност между 3 и 5 и коригирайте въз основа на Вашите RPM лимити
  • Семафорът трябва да бъде споделен (глобален или предаден като параметър), никога не го създавайте локално
  • Формулата RPM = семафор * (60 / средна_продължителност) помага за определяне на правилната стойност