Ugrás a tartalomhoz

asynchronous programming

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

asynchronous programming (tsz. asynchronous programmings)

  1. (informatika) Az aszinkron programozás célja, hogy egy program párhuzamosan, egymástól függetlenül hajthasson végre feladatokat, anélkül, hogy egyetlen hosszabb művelet megakadályozná a többi végrehajtását. Ez különösen fontos, ha például I/O-műveleteket (fájlolvasás, hálózati kommunikáció) végzünk, vagy nagy számításigényű feladatokat hajtunk végre, miközben a felhasználói felület válaszképes kell maradjon.

Miért hasznos az aszinkron programozás?

  • Elkerüli a blokkolást: A program nem áll le, amíg egy hosszú művelet végbemegy.
  • Hatékonyabb erőforrás-kezelés: Több CPU-magot, I/O-csatornát kihasználhatunk.
  • Gyorsabb válaszidők: Az alkalmazás hamarabb tud reagálni külső eseményekre.


A C++ lehetőségei

A modern C++ (főleg a C++11-től kezdve) számos eszközt kínál az aszinkron programozáshoz:

  • std::thread: Alapszintű szálkezelés.
  • std::async: Könnyű aszinkron futtatás és jövő (future) objektumok használata.
  • std::future és std::promise: Visszatérési értékek késleltetett lekérdezése.
  • std::packaged_task: Egy funkció vagy lambda becsomagolása szálak közé.
  • thread pool könyvtárak (pl. Boost, vagy saját megoldás).
  • C++20-tól coroutines (korutinok): Alacsony szintű, könnyű szálak.


1. std::thread

A legegyszerűbb formája az aszinkron programozásnak a std::thread.
Egy példát nézzünk:

#include <iostream>
#include <thread>

void hosszúFeladat() {
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "Feladat kész\n";
}

int main() {
    std::thread t(hosszúFeladat);
    std::cout << "Főszál dolgozik közben...\n";
    t.join(); // Megvárjuk a szál végét
}

A std::thread előnye, hogy teljes kontrollunk van a szál felett, de figyelni kell arra, hogy minden szálat join-oljunk, vagy detach-eljünk.


2. std::async

A std::async segítségével szinte egy sorban elindíthatunk egy aszinkron műveletet, amelyhez később egy future objektumon keresztül férhetünk hozzá.

#include <iostream>
#include <future>
#include <chrono>

int számol() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}

int main() {
    std::future<int> eredmény = std::async(std::launch::async, számol);
    std::cout << "Várok az eredményre...\n";
    int valasz = eredmény.get(); // Itt blokkol, amíg kész
    std::cout << "Eredmény: " << valasz << "\n";
}

Az async kényelmes, mert nem kell manuálisan kezelni a szálakat, viszont nem ad teljes kontrollt a futtatás ütemezésére.


3. std::promise és std::future

Ha egy szál valamikor a jövőben szeretne visszaadni egy értéket, akkor használhatunk std::promise-t és hozzá tartozó std::future-t.

#include <iostream>
#include <thread>
#include <future>

void dolgozik(std::promise<int> &&ígéret) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    ígéret.set_value(123);
}

int main() {
    std::promise<int> ígéret;
    std::future<int> jövő = ígéret.get_future();
    std::thread t(dolgozik, std::move(ígéret));
    std::cout << "Várakozás az eredményre...\n";
    std::cout << "Kaptuk: " << jövő.get() << std::endl;
    t.join();
}

Ez akkor hasznos, ha nem a std::async kényelmére van szükség, hanem explicit szálak és értékek áramoltatása történik.


4. std::packaged_task

A std::packaged_task-kal becsomagolhatunk egy tetszőleges függvényt, amely később futtatható és a visszatérési értéke egy future-ön keresztül lekérdezhető.

#include <iostream>
#include <future>
#include <thread>

int számol() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 5;
}

int main() {
    std::packaged_task<int()> feladat(számol);
    std::future<int> eredmény = feladat.get_future();
    std::thread(std::move(feladat)).detach();
    std::cout << "Az eredmény: " << eredmény.get() << "\n";
}

A packaged_task egy alacsonyabb szintű eszköz, mint az async, de jól jön, ha dinamikusan szeretnénk feladatokat kezelni.


5. Thread pool (szálkezelő medence)

A std::thread és az async is jó, de sok szál létrehozása és megsemmisítése drága művelet lehet. A thread pool egy fix számú szállal dolgozik, és csak feladatokat oszt ki nekik. Ez hatékonyabb, de bonyolultabb megvalósítást igényel. Erre használható például a Boost::asio vagy más külső könyvtárak.


6. Coroutines (korutinok, C++20)

A korutinok lehetővé teszik, hogy a függvények szinte „szüneteltethetőek” legyenek. Ez hasonlít a Pythonban ismert async/await szerkezetekhez.
A szintaxis elég összetett, de a legnagyobb előnye, hogy nem kell explicit szálakat vagy future-öket kezelni, a vezérlés és az állapot automatikusan történik.

#include <iostream>
#include <coroutine>

struct EgyediFuture {
    struct promise_type {
        EgyediFuture get_return_object() { return {}; }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_void() {}
        void unhandled_exception() {}
    };
};

EgyediFuture példa() {
    std::cout << "Előtte\n";
    co_await std::suspend_always{};
    std::cout << "Utána\n";
}

int main() {
    auto fut = példa();
    std::cout << "Főprogram vége\n";
}

Ez egy nagyon alap korutin példa, a valóságban ennél sokkal bonyolultabb keretrendszerek épülhetnek rá.


Tipikus hibák

  1. Elfelejtett join/detach – Ha elindítasz egy szálat és nem zárod le, undefined behavior lehet.
  2. Race condition – Több szál ugyanazt az adatot írja/olvassa egyszerre.
  3. Deadlock – Két szál vár egymásra örökké.
  4. Túl sok szál – Ha több ezer szálat hozol létre, az a rendszeredet lassítja.


Gyakorlati tanácsok

  • Ha egyszerű aszinkron működést akarsz, használd std::async-ot.
  • Ha nagy mennyiségű párhuzamos feladatot futtatsz, érdemes thread pool-t használni.
  • Ha hosszú távra tervezel modern C++-ban, érdemes megtanulni a korutinokat, de számíts rá, hogy meredek a tanulási görbéje.
  • Mindig figyelj a szálbiztonságra! Használj std::mutex, std::lock_guard vagy std::scoped_lock eszközöket.
  • Profilozz! Könnyen előfordulhat, hogy az aszinkron kódod lassabb lesz, mint egy jól optimalizált szekvenciális kód, ha túl sok overhead-et viszel be.


Összefoglalás

Az aszinkron programozás lehetővé teszi, hogy a programok gyorsabban reagáljanak és hatékonyabban használják a számítási erőforrásokat. A C++ eszköztára ebben a témában folyamatosan fejlődött, a legegyszerűbb std::thread-től kezdve a modern std::async-on át a korutinokig. Minden eszköznek megvan a maga helye: az egyszerű feladatokhoz érdemes a magas szintű absztrakciókat használni, míg összetettebb rendszerekhez a finomhangolhatóbb eszközök alkalmasak. Bár az aszinkron programozás bonyolult lehet, ha jól csináljuk, komoly teljesítménynyereséget és jobb felhasználói élményt eredményez.


További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=asynchronous_programming&oldid=3491032”