Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Semafuru izmantošana vienlaicīgu pieprasījumu ierobežošanai

Nodarbība 4 no 12 Atjaunota 2026. gada 30. jūlijs Augstākais
Šajā lapā
  1. Nekontrolētas vienlaicīguma problēma
  2. Kā darbojas semafori
  3. Pilns paraugs ar OpenAI SDK
  4. Pareizās semafora vērtības izvēle
  5. Izplatīta kļūda: globāls vai lokāls semafors
  6. Galvenās atziņas

Nekontrolētas vienlaicīguma problēma

Visu pieprasījumu paralēla izsūtīšana bez ierobežojumiem ir izplatīta kļūda. Ja tev ir jāapstrādā 200 jautājumi un tu palaid tos visus vienlaikus, tu sasniegsi API ātruma ierobežojumus, saņemsi HTTP 429 kļūdas un potenciāli uz laiku zaudēsi piekļuvi savai API atslēgai.

Semafors ir standarta risinājums vienlaicīgu pieprasījumu skaita kontrolei. Tas ir skaitītājs, kas ļauj paralēli darboties tikai noteiktam maksimālajam korutīnu skaitam.

5
Ieteicamais paralēlo pieprasījumu skaits
429
HTTP ātruma ierobežojuma kļūda
RPM
Pieprasījumi minūtē
TPM
Tokeni minūtē

Kā darbojas semafori

asyncio.Semaphore darbojas kā skaitītāja slēdzene. Kad korutīne ieiet async with semaphore blokā, skaitītājs samazinās. Kad tā iziet, skaitītājs palielinās. Ja skaitītājs sasniedz nulli, nākamās korutīnes gaida, līdz atbrīvojas vieta.

import asyncio
from asyncio import Semaphore

semaphore = Semaphore(5)  # maksimāli 5 vienlaicīgi pieprasījumi

async def process_request(request: str):
    async with semaphore:
        # Šī sadaļa ir ierobežota līdz 5 paralēlām izpildēm
        chat = client.chat.create(
            model="grok-4.20-0309-reasoning",
            max_tokens=100
        )
        chat.append(user(request))
        return await chat.sample()

Šajā piemērā, pat ja tu palaidīsi 100 korutīnes ar asyncio.gather, vienlaikus darbosies tikai 5. Pārējās 95 gaidīs savu kārtu.

Pilns paraugs ar OpenAI SDK

Lūk, tas pats paraugs, izmantojot AsyncOpenAI, ko bieži izvēlas savietojamības dēļ:

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)

Parametrs max_concurrent ir konfigurējams. Iestati to, ņemot vērā savus ātruma ierobežojumus (7. nodarbība).

Pareizās semafora vērtības izvēle

Aprēķini optimālo vērtību, balstoties uz saviem ātruma ierobežojumiem, bet ne tieši: tev jāņem vērā pieprasījuma ilgums. Ja tavs tarifs ļauj veikt 60 RPM un katrs pieprasījums ilgst aptuveni 10 sekundes, semafors ar vērtību 5 nodrošinās maksimāli 5 vienlaicīgus pieprasījumus jeb aptuveni 30 pieprasījumus minūtē – tas ir droši zem limita. Piemēro šo loģiku (RPM limits × vidējais ilgums ÷ 60) savam gadījumam. Tas izskaidro, kāpēc spriešanas modeļiem nepieciešams mazāks semafors: to pieprasījumi ilgst ilgāk, tāpēc pie vienādas vienlaicīguma caurlaidspēja minūtē krītas un pieaug momentānas pārslodzes risks. Ja šaubies, empīriskā pieeja ir drošākā: sāc ar zemu vērtību, starp 3 un 5, novēro 429 kļūdu biežumu un pakāpeniski palielini to, līdz atrodi līdzsvaru starp caurlaidspēju un stabilitāti.

Aptuvens aprēķins

Pieprasījumi minūtē = semafors * (60 / vidējais_ilgums_sekundēs)

Piemērs: semafors=5, ilgums=10s → 5 * (60/10) = 30 RPM
Piemērs: semafors=10, ilgums=5s → 10 * (60/5) = 120 RPM

Izplatīta kļūda: globāls vai lokāls semafors

# SLIKTI: jauns semafors katrā izsaukumā
async def bad_request(request: str):
    sem = Semaphore(5)  # katrs izsaukums izveido savu semafuru
    async with sem:
        return await client.chat.completions.create(...)

# LABI: semafors koplietots visiem izsaukumiem
sem = Semaphore(5)

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

Semaforam ir jābūt koplietotam starp visām korutīnēm. Ja tu to izveido lokāli katrā funkcijā, katrai korutīnei būs savs semafors un ierobežojums nedarbosies.

Galvenās atziņas

  • Semafora ierobežo vienlaicīgu API pieprasījumu skaitu, lai ievērotu ātruma limitus
  • Izmanto async with semaphore, lai aizsargātu API izsaukumus
  • Sāc ar vērtību no 3 līdz 5 un pielāgo to, ņemot vērā savus RPM limitus
  • Semaforam ir jābūt koplietotam (globālam vai padotam kā parametrs), nekad neveido to lokāli
  • Formula RPM = semafors * (60 / vidējais_ilgums) palīdz noteikt pareizo vērtību