Kooperatív többfeladatos munkavégzés (cooperative multitasking).

A párhuzamosság (concurrency) a megadott eszközök (szálak, aszinkronitás és folyamatok) nélkül, a generátorok (yield) és az eseményvezérelt (event-driven) architektúra kombinációjával valósítható meg a leghatékonyabban. Ez az úgynevezett kooperatív többfeladatos munkavégzés (cooperative multitasking), amely nem igényel zárakat (locks), így teljesen kiküszöböli a holtpontokat (deadlocks).

Az alábbi Python-program egyetlen szálon, memóriahatékonyan szimulálja a folyamatok egyidejű és biztonságos kezelését.

-----------------

from typing import Generator, Any

class KooperativFeladatkezelo:

    def __init__(self) -> None:

        self.feladatok: list[Generator[Any, None, None]] = []

    def hozzaad(self, feladat: Generator[Any, None, None]) -> None:

        self.feladatok.append(feladat)

    def futtat(self) -> None:

        """

        Egyetlen szálon, ciklikusan futtatja a feladatokat.

        A yield kulcsszóval történik az állapotmentés és a vezérlés visszaadása,

        így nincs szükség zárakra és kizárt a holtpontok kialakulása.

        """

        while self.feladatok:

            celok = []

            for feladat in self.feladatok[:]:

                try:

                    # A generátor léptetése a következő yield-ig

                    allapot = next(feladat)

                    celok.append((feladat, allapot))

                except StopIteration:

                    # Ha a feladat lefutott, eltávolítjuk

                    self.feladatok.remove(feladat)

            

            # Memóriakezelés: töröljük a felesleges hivatkozásokat az iterációk végén

            del celok

# --- Üzleti logikát megvalósító generátorok ---

def adatbazis_lekerdezes(felhasznalo_id: int) -> Generator[str, None, None]:

    print(f"[DB] {felhasznalo_id} adatainak lekérése indul...")

    yield "varakozas_i_o" # Várakozás szimulálása adatbázisra

    print(f"[DB] {felhasznalo_id} adatai sikeresen megérkeztek.")

    yield "feldolgozas_alatt"

    print(f"[DB] {felhasznalo_id} folyamat véget ért.")

def file_iratas(fajl_nev: str) -> Generator[str, None, None]:

    print(f"[FILE] {fajl_nev} megnyitása írásra...")

    yield "varakozas_i_o" # Várakozás szimulálása I/O műveletre

    print(f"[FILE] {fajl_nev} írása folyamatban...")

    yield "adat_mentve"

    print(f"[FILE] {fajl_nev} sikeresen lezárva.")

if __name__ == "__main__":

    # Inicializálás

    vezerlo = KooperativFeladatkezelo()

    # Feladatok regisztrálása

    vezerlo.hozzaad(adatbazis_lekerdezes(101))

    vezerlo.hozzaad(file_iratas("log_101.txt"))

    vezerlo.hozzaad(adatbazis_lekerdezes(102))

    # Eseményhurok indítása

    vezerlo.futtat()

---------------

[DB] 101 adatainak lekérése indul...

[FILE] log_101.txt megnyitása írásra...

[DB] 102 adatainak lekérése indul...

[DB] 101 adatai sikeresen megérkeztek.

[FILE] log_101.txt írása folyamatban...

[DB] 102 adatai sikeresen megérkeztek.

[DB] 101 folyamat véget ért.

[FILE] log_101.txt sikeresen lezárva.

[DB] 102 folyamat véget ért.

** Process exited - Return Code: 0 **

-------------------

Memóriakezelés és Párhuzamosság optimalizálása:

Holtpontok (deadlocks) elkerülése: A megosztott erőforrásokért (mint a globális változók) versengő szálak zárolása (locks) okozzák a holtpontokat. Mivel ez a program egyetlen szálon, szekvenciálisan hajtja végre a lépéseket a yield kulcsszóig, nincs szükség zárakra, így a holtpontok logikailag lehetetlenek.

Memóriakezelés: A celok lokális lista segít ideiglenesen tárolni az állapotokat, majd a del celok kifejezés azonnal jelzi a Python szemétgyűjtőjének (Garbage Collector), hogy felszabadíthatja a referenciák által lefoglalt memóriát az adott ciklus végén.

Optimális szálkezelés: Mivel ez az architektúra teljesen nélkülözi a hagyományos szálakat, elkerülhetjük a kontextusváltások (context switching) által generált memóriapazarlást és processzorterhelést. Az operációs rendszer szintjén a szálak kezelése és ütemezése megszűnik, helyette a programozó maga határozza meg a váltások pontjait.