Ugrás a tartalomhoz

concurrency

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

Angol


Főnév

concurrency (tsz. concurrencies)

  1. (informatika) egyidejűség

A konkurencia (concurrency) a számítástechnikában azt jelenti, hogy egy program képes egyszerre több műveletet is futtatni, akár párhuzamosan, akár egy időosztásos módon. A C++ nyelv modern szabványai (főként C++11-től kezdődően) beépített támogatást nyújtanak a konkurens programozáshoz, többek között a std::thread, std::mutex, std::async, std::future, és std::atomic eszközök révén.


🔄 Mi a különbség a konkurencia és a párhuzamosság között?

Fogalom Jelentés
Konkurencia Több feladat kezelése egyszerre, de nem feltétlenül párhuzamosan (lehet, hogy csak időosztással)
Párhuzamosság Több feladat valódi egyidejű végrehajtása, például több CPU magon


🧵 Alapfogalom: Szálak (Threads)

A szál egy végrehajtási egység egy folyamaton belül. Egy folyamat több szálat tartalmazhat, amelyek osztoznak az adatokon és a memórián.

C++11-től kezdve a nyelv szabványos könyvtára tartalmazza a <thread> fejléccel elérhető std::thread osztályt.


🛠 Példa: szál létrehozása

#include <iostream>
#include <thread>
using namespace std;

void hello() {
    cout << "Szia a második szálból!\n";
}

int main() {
    thread t(hello); // új szál indítása
    cout << "Szia a fő szálból!\n";
    t.join(); // várunk, míg a szál befejeződik
    return 0;
}

🧩 Szálkezelés

  • join() – fő szál megvárja a mellékszál végét
  • detach() – a szál háttérben fut, önállóan
  • joinable() – ellenőrizhető, hogy egy szál csatlakoztatható-e


🔐 Szinkronizáció – versenyhelyzetek elkerülése

Ha két szál ugyanazt az erőforrást (változót, memóriát stb.) akarja használni, versenyhelyzet alakulhat ki.

🧱 Mutex használata

#include <mutex>

mutex mtx;

void kritikus_szakasz() {
    mtx.lock();
    // kritikus rész: csak egy szál férhet hozzá
    mtx.unlock();
}

💡 Javasolt forma: lock_guard

void biztonsagos_funkcio() {
    lock_guard<mutex> l(mtx); // automatikus unlock a scope végén
    // biztonságos kód
}

⚠️ Versenyhelyzet (Race Condition)

Ez akkor fordul elő, amikor két vagy több szál egyszerre próbálja módosítani ugyanazt az adatot, és a végeredmény nem determinisztikus.


🔄 Alternatíva: std::atomic

Az atomi típusok biztosítják, hogy egy változóval való minden művelet oszthatatlanul hajtódjon végre.

#include <atomic>
atomic<int> szamlalo(0);

void novel() {
    szamlalo++;
}

⏳ std::async, std::future – késleltetett végrehajtás

#include <future>

int hosszadalmasMuvelet() {
    this_thread::sleep_for(chrono::seconds(2));
    return 42;
}

int main() {
    future<int> eredmeny = async(hosszadalmasMuvelet);
    cout << "Várakozás...\n";
    cout << "Eredmény: " << eredmeny.get(); // blokkolás a végeredményig
}

📬 promise és future – kézi eredmény továbbítás

#include <future>

void producer(promise<int>&& p) {
    p.set_value(100);
}

int main() {
    promise<int> p;
    future<int> f = p.get_future();
    thread t(producer, move(p));
    cout << "Kapott érték: " << f.get();
    t.join();
}

⚙️ Fejlettebb szinkronizációs eszközök

Eszköz Leírás
condition_variable Értesítés eseményekről
shared_mutex Több olvasó, egy író
barrier, latch Szálak összehangolása (C++20)
semaphore Erőforrás hozzáférés korlátozása (C++20)


💥 Tipikus hibák

Hiba Leírás
Deadlock Két szál kölcsönösen vár egymásra
Race condition Véletlenszerű viselkedés nem szinkronizált hozzáférés miatt
Detached szál elhal detach() után a szál hibát okozhat, ha nem fut tovább vagy eléri a hibás állapotot
Elfelejtett join() A fő szál befejeződhet a többi előtt, crash


🧪 Példa: több szál számol

#include <thread>
#include <vector>
#include <iostream>
using namespace std;

void szamolj(int tol, int ig, int& osszeg, mutex& m) {
    int resz = 0;
    for (int i = tol; i <= ig; ++i)
        resz += i;

    lock_guard<mutex> l(m);
    osszeg += resz;
}

int main() {
    mutex m;
    int osszeg = 0;
    thread t1(szamolj, 1, 50, ref(osszeg), ref(m));
    thread t2(szamolj, 51, 100, ref(osszeg), ref(m));

    t1.join();
    t2.join();

    cout << "Összeg: " << osszeg << endl;
}

🎓 Összefoglalás

Fogalom Példa
Szál indítása std::thread t(f);
Szinkronizáció std::mutex, lock_guard
Atomi változó std::atomic<int>
Async futtatás std::async, std::future
Értesítések std::condition_variable


🛤️ Továbblépés

  • Thread pools (nincs std támogatás, de Boost, vagy saját)
  • Actor model és message passing
  • Lock-free struktúrák
  • Parallel STL algoritmusok (<execution> - C++17)

További információk

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