Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Asinchroninė architektūra ir eilės

Paskaita 7 iš 20 Atnaujinta 2026 m. liepos 28 d. Pažengusiems
Šiame puslapyje
  1. Kodėl niekada neturėtum blokuoti kviesdamas LLM
  2. Gamintojo / Vartotojo šablonas
  3. Kvotų laikymasis vietoj jų viršijimo
  4. Momentinis valdymo grąžinimas
  5. Svarbiausi punktai

Kodėl niekada neturėtum blokuoti kviesdamas LLM

API užklausa kalbos modeliui trunka nuo vienos iki trisdešimties sekundžių, priklausomai nuo modelio ir užklausos sudėtingumo. Serverio procesui trisdešimt sekundžių yra amžinybė: tuo metu laukiantis gijas nieko neveikia, tačiau vis tiek užima vietą. Padaugink tai iš šimto vienu metu vykdomų užklausų ir tavo programa žlugs ne todėl, kad atlieka per daug skaičiavimų, o todėl, kad per daug laukia.

Asinchroninė architektūra, paremta eile, vienu metu išsprendžia tris problemas. Ji sugeria srauto šuolius, nes eilė auga vietoj to, kad atmestų užklausas. Ji centralizuoja kartojimo logiką, nes nepavykęs uždavinys grįžta į eilę vietoj to, kad dingtų kartu su jį sukėlusia HTTP užklausa. Be to, ji atskiria tavo servisus: komponentas, gaunantis užklausas, nebeturi žinoti, kiek laiko vykdančiam komponentui prireiks joms apdoroti.

Gamintojo / Vartotojo šablonas

Pagrindinė struktūra remiasi dviem objektais. Uždavinys aprašo, ką reikia atlikti, ir dabartinę apdorojimo būseną; eilė paskirsto šiuos uždavinius darbuotojų baseinui, kuris juos vykdo lygiagrečiai. Būsenos modeliavimas kaip enumeracija, o ne laisvos formos eilutė, padeda išvengti dažniausiai pasitaikančių klaidų tokio tipo kode: kai dvi programos dalys rašo "terminee" ir "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:
    """Asinchroninė eilė LLM užklausoms."""

    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:
        """Prideda uždavinį į eilę."""
        self.results[task.id] = task
        await self.queue.put(task)
        return task.id

    async def worker(self, worker_id: int):
        """Darbuotojas, apdorojantis uždavinius iš eilės."""
        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):
        """Paleidžia darbuotojus."""
        workers = [
            asyncio.create_task(self.worker(i))
            for i in range(self.num_workers)
        ]
        return workers

    async def wait_completion(self):
        """Laukia, kol visi uždaviniai bus apdoroti."""
        await self.queue.join()

Du šio darbuotojo aspektai nusipelno tavo dėmesio, nes jie pasitaiko kiekviename realiame įgyvendinime. Skaitiklis attempts saugomas pačiame uždavinyje, o ne darbuotojo atmintyje, todėl bet kuris kitas darbuotojas gali perimti iš naujo į eilę įdėtą uždavinį neprarandant jo istorijos. Kvietimas task_done() yra finally bloke, kad būtų garantuota, jog eilė niekada neužstrigs neribotam laikui, jei netikėta išimtis apeitų except bloką: be jo, niekada negrįžtantis join() būtų simptomas, kurį diagnozuoti yra labai sunku.

Kviečiančiojo pusėje naudojimas yra paprastas: paleisk darbuotojus, įdėk uždavinius į eilę, palauk, surink rezultatus ir sustabdyk.

async def process_documents(documents: list[str]):
    queue = ProcessingQueue(num_workers=10)
    workers = await queue.start()

    # Pridėti uždavinius
    for i, doc in enumerate(documents):
        task = Task(
            id=f"doc-{i}",
            prompt=f"Apibendrink šį dokumentą: {doc}",
        )
        await queue.add(task)

    # Laukti pabaigos
    await queue.wait_completion()

    # Surinkti rezultatus
    for task_id, task in queue.results.items():
        print(f"{task_id}: {task.status.value}")

    # Sustabdyti darbuotojus
    for w in workers:
        w.cancel()

Kvotų laikymasis vietoj jų viršijimo

OpenAI taiko dvi vienu metu galiojančias ribas: užklausų skaičių per minutę ir tokenų skaičių per minutę. Dešimties darbuotojų baseinas, siunčiantis viską, ką gali, greitai pasieks vieną iš šių ribų, gaus ribojimo klaidas, bandys kartoti ir tik dar labiau padidins spūstis. Geriau savanoriškai sulėtinti veiksmą pirminėje grandyje, nei būti atmestam galutinėje.

Toliau pateiktas ribotuvas taiko tokenų kibirą slenkančio vienos minutės lango principu. Jis saugo dvi istorijas – neseniai atliktų užklausų laiko žymas ir laiko žymų bei tokenų poras – išvalo įrašus, kurie iškrito iš lango, ir laukia, jei būtų viršyta bet kuri riba. asyncio užraktas yra būtinas: be jo dešimt darbuotojų vienu metu įvertintų tą pačią situaciją ir visi dešimt nuspręstų, kad dar yra vietos.

import asyncio
import time

class RateLimiter:
    """Ribotuvas, pagrįstas tokenų kibiru."""

    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):
        """Laukia, jei reikia, kad būtų laikomasi ribų."""
        async with self.lock:
            now = time.time()
            window = 60.0

            # Išvalyti įrašus už lango ribų
            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
            ]

            # Tikrinti RPM (užklausos per minutę)
            if len(self.recent_requests) >= self.rpm:
                wait_time = self.recent_requests[0] + window - now
                await asyncio.sleep(wait_time)

            # Tikrinti TPM (tokenai per minutę)
            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))

Parametras estimated_tokens nusipelno komentarų: tikrosios kainos nežinai, kol negauni atsakymo, todėl dirbi su įverčiu. Geriau jį nustatyti dosniau nei tiksliai. Sistemingas įverčių mažinimas reiškia apsaugos išjungimą būtent tada, kai ji būtų naudingiausia.

Momentinis valdymo grąžinimas

Kai apdorojimas trunka kelias minutes, HTTP kliento laukimas tampa nebeįmanomas: proxy, naršyklės ir apkrovos balansuotojo laiko limitai suveiks anksčiau, nei baigsi darbą. „Webhook“ šablonas apverčia atsakomybę. Tavo galinis taškas priima užklausą, iškart grąžina uždavinio ID ir praneša kvietėjui, kai rezultatas yra paruoštas, nereikalaujant periodinio apklausimo.

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

@app.post("/api/analyze")
async def start_analysis(
    request: dict,
    background_tasks: BackgroundTasks,
):
    """Pradeda foninę analizę ir praneša per 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,
):
    """Vykdo analizę ir siunčia rezultatą per 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,
            })

Visada saugok grąžintą ID ir susijusią būseną patikimoje saugykloje. Webhook gali pasimesti, o kvietėjas privalo išlaikyti galimybę pats gauti rezultatą.

Svarbiausi punktai

  • Naudok asinchronines eiles, kad atskirtum duomenų priėmimą nuo apdorojimo
  • Įgyvendink ribotuvą, kad laikytumeisi OpenAI kvotų
  • Darbuotojuose tvarkyk kartojimus naudodamas eksponentinį delsą
  • Ilgai trunkantiems uždaviniams vietoj apklausimo rinkis webhook šabloną