Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Párhuzamosítás és egyidejűség

8. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. A közös várakozás nem egyenlő a közös számítással
  2. Egyidejű hívások indítása
  3. A Map-Reduce minta alkalmazása szövegekre
  4. Mikor válik ismét relevánssá a multiprocessing
  5. A valós átviteli sebesség ellenőrzése
  6. Főbb megállapítások

A közös várakozás nem egyenlő a közös számítással

Egy OpenAI API-hívás I/O-kötött művelet: a programod nem számokat crunchol, hanem egy hálózati válaszra vár. Ez a természet diktálja a megfelelő eszközt. A párhuzamosítás (multiprocessing értelemben) több magon osztja el a számítást; ez munkánként egy teljes folyamatot emészt fel, és száz, hálózatra váró folyamat futtatása tiszta pazarlás. Az egyidejűség (concurrency), amelyet az asyncio biztosít, lehetővé teszi, hogy egyetlen folyamat százszoros várakozást kezeljen elhanyagolható költséggel. Ez maximalizálja a hívásaid átviteli sebességét.

A különbség több mint elméleti: egy csapat, amely folyam-poollel párhuzamosítja az LLM-hívásait, több gigabájt memóriát fogyaszt el nulla nyereségért cserébe, összehasonlítva néhány sor asyncio kóddal.

Egyidejű hívások indítása

Az SDK aszinkron klienst tesz közzé, az AsyncOpenAI-t, amelynek hívásai az await kulcsszóval várakoznak. Több korutin asyncio.gather segítségével történő összegyűjtése lehetővé teszi, hogy mindegyik egyszerre haladjon előre, így a teljes időtartam a leglassabb hívás idejéhez közelít, nem pedig az összegükhöz.

import asyncio
import openai

client = openai.AsyncOpenAI()

async def single_call(prompt: str, model: str = "gpt-5.6-terra") -> str:
    """Egyetlen aszinkron API-hívás."""
    response = await client.responses.create(
        model=model,
        input=prompt,
    )
    return response.output_text

async def concurrent_calls(prompts: list[str]) -> list[str]:
    """Minden hívást egyidejűleg indít el."""
    tasks = [single_call(prompt) for prompt in prompts]
    results = await asyncio.gather(*tasks, return_exceptions=True)

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Hiba a(z) {i}. promptnál: {result}")

    return [r for r in results if not isinstance(r, Exception)]

A return_exceptions=True flag az, ami megkülönbözteti a prototípust a gyártásra kész feldolgozástól. Enélkül az első kivétel megszakítja a gather-t, és elveszíted a már megszerzett kilencvenkilenc eredményt. Ezzel szemben a hibák olyan értékekké válnak, amelyeket saját tempódban vizsgálsz meg, naplózol és próbálsz újra.

Ennek a nyers verziónak azonban van egy azonnali hibája: ezer hívás egyszerre történő indítása másodpercek alatt átlépi a sebességkorlátokat (rate limits). Egy szemafor oldja meg ezt a problémát úgy, hogy csak egy fix számú egyidejű hívást engedélyez, míg a többiek türelmesen várják a sorukat. A húsz ésszerű kiindulópont, amelyet szervezeted tényleges kvótái alapján kell beállítani.

async def calls_with_limit(
    prompts: list[str],
    max_concurrency: int = 20,
) -> list[str]:
    """Korlátozza az egyidejű hívások számát."""
    semaphore = asyncio.Semaphore(max_concurrency)

    async def limited_call(prompt: str) -> str:
        async with semaphore:
            return await single_call(prompt)

    tasks = [limited_call(prompt) for prompt in prompts]
    return await asyncio.gather(*tasks, return_exceptions=True)

A Map-Reduce minta alkalmazása szövegekre

Egy kétszáz oldalas dokumentum nem foglalható össze egyetlen hívással, és a szekvenciális szeletelés percekig tartana. A map-reduce minta itt természetesen alkalmazható: darabokra vágás, minden darab egyidejű összefoglalása, majd a modell kérése az összefoglalók szintézisére. A map fázis teljes mértékben profitál az egyidejűségből, míg a reduce fázis egyetlen hívás egy már rövid szövegen.

async def map_reduce_summary(
    document: str,
    chunk_size: int = 3000,
) -> str:
    """Hosszú dokumentum összefoglalása párhuzamos map-reduce segítségével."""

    # MAP fázis: felosztás és összefoglalás párhuzamosan
    chunks = [
        document[i:i + chunk_size]
        for i in range(0, len(document), chunk_size)
    ]

    map_prompts = [
        f"Foglald össze ezt a részt 3 kulcspontban:\n\n{chunk}"
        for chunk in chunks
    ]

    partial_summaries = await calls_with_limit(map_prompts, max_concurrency=10)

    # REDUCE fázis: összefoglalók egyesítése
    summary_text = "\n\n---\n\n".join(
        r for r in partial_summaries if isinstance(r, str)
    )

    final_summary = await single_call(
        f"Szintetizáld ezeket a részleges összefoglalókat egy koherens, "
        f"5 kulcspontból álló összefoglalóvá:\n\n{summary_text}"
    )

    return final_summary

Az if isinstance(r, str) szűrés ugyanolyan termékdöntés, mint technikai óvintézkedés: azt jelenti, hogy a végső szintézis elkészül akkor is, ha három darab csendben meghibásodott. A kontextustól függően ez pontosan az, amit szeretnél, vagy elfogadhatatlan. Dönts tudatosan, és mindenképpen naplózd az elveszett darabok számát.

Mikor válik ismét relevánssá a multiprocessing

Maradnak ritka helyzetek, amikor a számítás veszi át az irányítást: nehéz utófeldolgozás a válaszokon, entitáskinyerés, pontozás, strukturált elemzés. Ez a munka CPU-kötött, és nem nyer semmit az asyncio-val. Az elegáns kombináció a két rendszer láncolása egyetlen folyamatban: hálózati hívások egyidejűleg, majd a számítás elosztva egy folyam-poolon keresztül a run_in_executor segítségével.

import asyncio
from concurrent.futures import ProcessPoolExecutor

def heavy_post_processing(text: str) -> dict:
    """CPU-kötött feldolgozás az eredményen (NLP, elemzés stb.)."""
    # Példa: entitáskinyerés, pontozás stb.
    words = text.split()
    return {
        "word_count": len(words),
        "unique_words": len(set(words)),
    }

async def complete_pipeline(prompts: list[str]) -> list[dict]:
    """Folyamat: aszinkron LLM-hívások + párhuzamos CPU utófeldolgozás."""
    # 1. lépés: egyidejű LLM-hívások
    llm_results = await calls_with_limit(prompts)

    # 2. lépés: párhuzamos utófeldolgozás (CPU)
    loop = asyncio.get_event_loop()
    with ProcessPoolExecutor(max_workers=4) as pool:
        tasks = [
            loop.run_in_executor(pool, heavy_post_processing, r)
            for r in llm_results
            if isinstance(r, str)
        ]
        final_results = await asyncio.gather(*tasks)

    return final_results

Mielőtt bevezetnéd, ellenőrizd, hogy a számítás valóban indokolja-e a pool használatát: az adatok másik folyamatba történő sorosításának költsége van, és néhány milliszekundumig tartó kezelések esetén ez a költség meghaladja a nyereséget.

A valós átviteli sebesség ellenőrzése

A max_concurrency hangolása nem találgatás. Ha túl alacsony, kihasználatlanul hagyod az átviteli sebességet; ha túl magas, olyan sebességkorlátokba ütközöl (rate limits), amelyek több időbe kerülnek, mint amennyit megtakarítanak. Mérd le a tényleges terheléseden, változtatva az értéket, és figyeld mind az átviteli sebességet, mind a sikeres hívások számát – egy nagyon gyors folyamat, amely ötből egyszer meghibásodik, nem gyors.

import time

async def benchmark_throughput(num_requests: int = 100):
    """Méri a folyamatod valós átviteli sebességét."""
    prompts = [
        f"Adj egy érdekes tényt a(z) {i}. számmal."
        for i in range(num_requests)
    ]

    start = time.perf_counter()
    results = await calls_with_limit(prompts, max_concurrency=20)
    duration = time.perf_counter() - start

    successes = sum(1 for r in results if isinstance(r, str))
    print(f"Kérések: {num_requests}")
    print(f"Sikeresek: {successes}")
    print(f"Időtartam: {duration:.1f}s")
    print(f"Átviteli sebesség: {successes / duration:.1f} kérés/mp")

Főbb megállapítások

  • Használd az AsyncOpenAI-t és az asyncio.gather-t az I/O egyidejűséghez
  • Korlátozd az egyidejűséget szemaforral a kvóták betartása érdekében
  • A map-reduce minta párhuzamosítja a hosszú dokumentumok feldolgozását
  • A ProcessPoolExecutor-t csak CPU-intenzív utófeldolgozásra tartalékold