Ailtireacht Asincronach agus Ciúnna
Ar an leathanach seo
Cén fáth nach mbacann tú riamh ar ghlaonna LLM
Tógann glaonna API chuig samhlacha teanga idir soicind amháin agus tríocha soicind, ag brath ar an tsamhail agus ar chastacht an iarratais. Is síoraíocht tríocha soicind do phróiseas freastalaí: le linn na tréimhse sin, ní dhéanann an snáithe a bhfuiltear ag fanacht leis aon rud, ach tá áit fós á ghabháil aige. Méadaigh é sin faoi chéad iarratas comhuaineach, agus tuileoidh d’iarratas ní mar gheall go bhfuil sé ag ríomh an iomarca, ach mar gheall go bhfuil sé ag fanacht an iomarca.
Réitíonn ailtireacht asincronach atá bunaithe ar chiúna trí fhadhb ar fad. Súnn sé buaicphointí tráchta, ós rud é go bhfásann an chiúna in ionad iarratais a dhiúltú. Lárnaitheann sé loighic athiarrachta, toisc go dtéann tasc teipthe ar ais chuig an gciúna in ionad imeacht leis an iarratas HTTP a spreag é. Agus díthiomsaíonn sé do sheirbhísí: ní gá don chomhpháirt a fhaigheann iarratais a fhios a bheith aici cá fhad a thógann sé ar an gcomhpháirt feidhmiúcháin iad a phróiseáil.
An Patrún Táirgeora / Tomhaltóra
Braitheann an bhunstruchtúr ar dhá oibiacht. Déanann tasc cur síos ar an rud atá le déanamh agus ar stádas reatha na próiseála; dáileann ciúna na tascanna seo ar linn oibrithe a ídíonn iad go comhthreomhar. Seachnaíonn samhaltú stádais mar áireamh in ionad teaghráin saorchrutha an cineál is coitianta fabhtanna sa chód seo: dhá chuid den chlár ag scríobh "terminee" agus "terminée".
import asyncio
from dataclasses import dataclass, field
from enum import Enum
class TaskStatus(Enum):
PENDING = "pending"
IN_PROGRESS = "in_progress"
COMPLETED = "completed"
FAILED = "failed"
@dataclass
class Task:
id: str
prompt: str
model: str = "gpt-5.6-terra"
status: TaskStatus = TaskStatus.PENDING
result: str | None = None
attempts: int = 0
max_attempts: int = 3
class ProcessingQueue:
"""Ciúna asincronach le haghaidh glaonna LLM."""
def __init__(self, num_workers: int = 5):
self.queue: asyncio.Queue[Task] = asyncio.Queue()
self.results: dict[str, Task] = {}
self.num_workers = num_workers
async def add(self, task: Task) -> str:
"""Cuir tasc leis an gciúna."""
self.results[task.id] = task
await self.queue.put(task)
return task.id
async def worker(self, worker_id: int):
"""Oibrí a phróiseálann tascanna ón gciúna."""
import openai
client = openai.AsyncOpenAI()
while True:
task = await self.queue.get()
task.status = TaskStatus.IN_PROGRESS
task.attempts += 1
try:
response = await client.responses.create(
model=task.model,
input=task.prompt,
)
task.result = response.output_text
task.status = TaskStatus.COMPLETED
except Exception as e:
if task.attempts < task.max_attempts:
task.status = TaskStatus.PENDING
await self.queue.put(task)
else:
task.status = TaskStatus.FAILED
task.result = str(e)
finally:
self.queue.task_done()
async def start(self):
"""Tosaigh na hoibrithe."""
workers = [
asyncio.create_task(self.worker(i))
for i in range(self.num_workers)
]
return workers
async def wait_completion(self):
"""Fan go ndéantar gach tasc a phróiseáil."""
await self.queue.join()
Tá dhá shonra sa oibrí seo a thuilleann d’aird toisc go bhfeictear i ngach cur chun feidhme sa saol mór iad. Tá an t-áireamh attempts ar an tasc féin, ní ar an oibrí, rud a ligeann d’aon oibrí eile tasc athchiúnaithe a phiocadh suas gan a stair a chailleadh. Tá an glaonna task_done() suite laistigh de bhloc finally chun a ráthú nach mbacfaidh an chiúna go deo má sháraíonn eisceacht gan choinne an bloc except: gan é, is é join() nach dtéann i gcrích riamh an comhartha, agus is pianmhar é a dhiagnóisiú.
Ar thaobh an ghlaoiteora, tá an úsáid simplí: tosaigh na hoibrithe, cuir tascanna sa chiúna, fan, bailigh torthaí, agus stop.
async def process_documents(documents: list[str]):
queue = ProcessingQueue(num_workers=10)
workers = await queue.start()
# Cuir tascanna leis
for i, doc in enumerate(documents):
task = Task(
id=f"doc-{i}",
prompt=f"Déan achoimre ar an doiciméad seo: {doc}",
)
await queue.add(task)
# Fan ar chríochnú
await queue.wait_completion()
# Bailigh torthaí
for task_id, task in queue.results.items():
print(f"{task_id}: {task.status.value}")
# Stop na hoibrithe
for w in workers:
w.cancel()
Cuótaí a urramú in ionad iad a bhriseadh
Forfheidhmíonn OpenAI dhá theorainn chomhuaineacha: iarratais in aghaidh an nóiméid agus tokenanna in aghaidh an nóiméid. Buailfidh linn deich n-oibrí a sheolann gach rud is féidir leo ceann amháin nó an ceann eile, faighidh siad earráidí teorainn ráta, déanfaidh siad iarracht arís, agus measfaidh siad an plódú. Is fearr moilliú go deonach suas an sruth ná diúltú a fháil síos an sruth.
Cuirtear buicéad tokenanna i bhfeidhm leis an teorannóir thíos thar fhuinneog shleamhnáil de nóiméad amháin. Coinníonn sé dhá stair— stampaí ama d’iarratais le déanaí agus péirí stampa ama/tokenanna — glanann sé iontrálacha a thit amach as an bhfuinneog, agus ansin fanann sé dá sárófaí ceachtar den teorainn. Tá an glas asyncio riachtanach: gan é, dhéanfadh deich n-oibrí measúnú ar an staid chéanna go comhuaineach agus chinneodh na deich gcinn go bhfuil spás fós ann.
import asyncio
import time
class RateLimiter:
"""Teorannóir ráta bunaithe ar bhuicéad tokenanna."""
def __init__(self, rpm: int = 500, tpm: int = 200_000):
self.rpm = rpm
self.tpm = tpm
self.recent_requests: list[float] = []
self.recent_tokens: list[tuple[float, int]] = []
self.lock = asyncio.Lock()
async def wait(self, estimated_tokens: int = 1000):
"""Fanann sé más gá chun teorainneacha a urramú."""
async with self.lock:
now = time.time()
window = 60.0
# Glan iontrálacha lasmuigh den fhuinneog
self.recent_requests = [
t for t in self.recent_requests
if now - t < window
]
self.recent_tokens = [
(t, n) for t, n in self.recent_tokens
if now - t < window
]
# Seiceáil RPM
if len(self.recent_requests) >= self.rpm:
wait_time = self.recent_requests[0] + window - now
await asyncio.sleep(wait_time)
# Seiceáil TPM
tokens_used = sum(n for _, n in self.recent_tokens)
if tokens_used + estimated_tokens > self.tpm:
wait_time = self.recent_tokens[0][0] + window - now
await asyncio.sleep(wait_time)
self.recent_requests.append(time.time())
self.recent_tokens.append((time.time(), estimated_tokens))
Tuilleann an paraiméadar estimated_tokens focal: ní fios duit an costas iarbhír go dtí go dtagann an freagra, mar sin oibríonn tú le meastachán. Déan é fial seachas cruinn. Is ionann meastachán a dhéanamh go córasach faoi bhun agus cosaint a dhíchumasú díreach nuair a bheadh sé úsáideach.
Rialú a thabhairt ar ais láithreach
Le haghaidh próiseála a thógann roinnt nóiméad, níl sé indéanta a thuilleadh fanacht le cliant HTTP: tiocfaidh teorainneacha ama seachfhreastalaí, brabhsálaí, agus cothromaitheora ualaí i bhfeidhm sula gcríochnóidh tú. Aisiompíonn an patrún webhook an fhreagracht. Glacann do phointe deiridh leis an iarratas, filleann sé ID tasc láithreach, agus fógraíonn sé an glaoiteoir nuair atá an toradh ann, gan gá le polaithe tréimhsiúil.
from fastapi import FastAPI, BackgroundTasks
app = FastAPI()
@app.post("/api/analyze")
async def start_analysis(
request: dict,
background_tasks: BackgroundTasks,
):
"""Tosaíonn sé anailís chúlra agus fógraíonn sé trí webhook."""
task_id = generate_id()
background_tasks.add_task(
run_analysis,
task_id=task_id,
document=request["document"],
webhook_url=request.get("webhook_url"),
)
return {"task_id": task_id, "status": "in_progress"}
async def run_analysis(
task_id: str,
document: str,
webhook_url: str | None,
):
"""Ritheann sé an anailís agus seolann sé an toradh trí webhook."""
import httpx
result = await call_llm(document)
if webhook_url:
async with httpx.AsyncClient() as http:
await http.post(webhook_url, json={
"task_id": task_id,
"status": "completed",
"result": result,
})
Stóráil an t-ID a filltear agus an staid ghaolmhar in áit éigin marthanach i gcónaí. Is féidir le webhook dul amú, agus caithfidh an glaoiteoir an cumas a choinneáil an toradh a fháil dóibh féin.
Príomhphointí
- Úsáid ciúnna asincronacha chun ionghabháil a dhíthiomsú ó phróiseáil
- Cuir teorannóir ráta i bhfeidhm chun cuótaí OpenAI a urramú
- Láimhseáil athiarrachtaí le cúlú easpónantúil i d’oibrithe
- Do thascanna fadraoin, roghnaigh patrún webhook thar pholaithe