Lähe põhisisu juurde
Eesti— Vali keel
Menüü

asyncio.gather rühmtöötluseks

Õppetund 5 / 12 Värskendatud 30. juuli 2026 Edasijõudnutele
Sellel lehel
  1. Paralleelsete päringute orkestreerimine
  2. Põhisüntaks
  3. Täielik muster: Pakett koos semaforiga
  4. Vigade käsitlemine paketis
  5. Alam-pakkettideks jagamine (tükeldamine)
  6. Edenemise jälgimine
  7. Peamised punktid

Paralleelsete päringute orkestreerimine

asyncio.gather on põhifunktsioon mitme korutiini paralleelseks käivitamiseks ja kõigi tulemuste kogumiseks. Koos semaforiga kasutades saad tõhusalt töödelda päringute pakette, austades samal ajal API piiranguid.

Põhisüntaks

import asyncio

requests = ["Question 1", "Question 2", "Question 3"]
tasks = [process_request(r) for r in requests]
responses = await asyncio.gather(*tasks)

asyncio.gather võtab vastu muutuva arvu korutiine (seetõttu kasutatakse loendi lahti pakkimiseks *tasks) ja tagastab tulemuste loendi samas järjekorras, nagu ülesanded esitati. See on oluline punkt: isegi kui küsimus 3 lõpeb enne küsimust 1, sisaldab responses[0] alati tulemust küsimusele 1.

Täielik muster: Pakett koos semaforiga

Siin on muster, mida kasutad tootmiskeskkonnas kõige sagedamini:

import os
from asyncio import Semaphore
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 process_batch(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    return await asyncio.gather(*tasks)

See muster kapseldab semafori paketi funktsiooni sisse. Sul tuleb lihtsalt kutsuda process_batch(prompts) ja saada vastuste loend.

Vigade käsitlemine paketis

Vaikimisi, kui üksainus korutiin viskab erindi, tühistab asyncio.gather kõik ja levitab vea edasi. Parameeter return_exceptions=True muudab seda käitumist:

async def safe_batch(prompts: list[str]) -> list[str | Exception]:
    sem = Semaphore(5)

    async def single_request(prompt: str) -> str:
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return results

# Kasutamine
results = await safe_batch(mes_prompts)
for i, result in enumerate(results):
    if isinstance(result, Exception):
        print(f"Error on prompt {i}: {result}")
    else:
        print(f"Result {i}: {result[:100]}...")

Kasutades return_exceptions=True, salvestatakse vead tulemuste loendis väärtustena. Seejärel saad tuvastada ebaõnnestunud päringud ja need uuesti proovida.

Alam-pakkettideks jagamine (tükeldamine)

Väga suurte mahtude korral on parem jagada töö alam-pakkettideks, mitte käivitada tuhandeid ülesandeid samaaegselt:

async def chunked_batch(
    prompts: list[str],
    chunk_size: int = 50,
    max_concurrent: int = 5
) -> list[str]:
    all_results = []

    for i in range(0, len(prompts), chunk_size):
        chunk = prompts[i:i + chunk_size]
        print(f"Processing batch {i//chunk_size + 1} ({len(chunk)} prompts)")
        results = await process_batch(chunk, max_concurrent)
        all_results.extend(results)

    return all_results

Tükeldamisel on mitu eelist: saad kuvada edenemist, salvestada vahepealseid tulemusi ja piirata mälukasutust. Kui üks alampakkett ebaõnnestub, ei kaota sa eelmiste alampakkettide tulemusi.

Edenemise jälgimine

Suurte pakkettide puhul on kasulik edenemisnäitaja:

import asyncio
from asyncio import Semaphore

async def batch_with_progress(prompts: list[str], max_concurrent: int = 5) -> list[str]:
    sem = Semaphore(max_concurrent)
    completed = 0
    total = len(prompts)

    async def single_request(prompt: str) -> str:
        nonlocal completed
        async with sem:
            response = await client.chat.completions.create(
                model="grok-4.5",
                messages=[{"role": "user", "content": prompt}]
            )
            completed += 1
            print(f"\r{completed}/{total} completed", end="", flush=True)
            return response.choices[0].message.content

    tasks = [single_request(p) for p in prompts]
    results = await asyncio.gather(*tasks)
    print()  # uus rida pärast edenemist
    return results

Peamised punktid

  • asyncio.gather(*tasks) käivitab korutiinid paralleelselt ja tagastab tulemused algses järjekorras
  • return_exceptions=True hoiab ära olukorra, kus üksainus viga nurjab kogu paketi
  • Tükeldamine võimaldab hallata väga suuri mahte ilma mälu üle koormamata
  • Kombineeri gather alati semaforiga, et austada kiirusepiiranguid
  • Lisa pikaajaliste protsesside jaoks edenemise jälgimine