Semafuru izmantošana vienlaicīgu pieprasījumu ierobežošanai
Šajā lapā
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.
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