std::atomic

Angol

Főnév

std::atomic (tsz. std::atomics)

(informatika) A std::atomic a C++11-ben bevezetett sablonos típus, amelyet arra terveztek, hogy biztonságos módon kezeljük a megosztott változókat több szál (thread) között.

Amikor több szál próbál egyszerre módosítani egy változót, fennáll a race condition veszélye — azaz az adatok inkonzisztenssé válhatnak, mert a műveletek időzítése kiszámíthatatlan.

A std::atomic garantálja, hogy ezek az olvasási/írási műveletek atomiak lesznek – vagyis: - Teljesen végrehajtódnak, vagy egyáltalán nem - Nem lehet őket “félbeszakítani” más szálak által - Így nincs adatvesztés vagy összeomlás

🛠️ Hogyan működik?

A std::atomic egy sablontípus (template), amely a legtöbb primitív típushoz működik: - std::atomic<int> - std::atomic<bool> - std::atomic<float> stb.

🔁 Alapműveletek (mind atomiak):

Olvasás: int x = atomic_var.load();
Írás: atomic_var.store(42);
Növelés/csökkentés: atomic_var++;, --atomic_var;
Összegzés: atomic_var.fetch_add(10);

✅ Példa `std::atomic` használatára

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 10000; ++i) {
        counter++;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

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

    std::cout << "Végső érték: " << counter << std::endl;
}

🧪 Eredmény: mindig 20000 — nincs race condition! 🎯

Ha itt sima int-et használnál std::atomic<int> helyett, akkor gyakran kisebb számokat kapnál (pl. 17341, 19203, stb.), mert a két szál egyszerre próbálná írni ugyanazt a memóriacímet → adatvesztés.

❗ Fontos tudnivalók

🔒 `std::atomic` vs `std::mutex`

std::atomic nagyon hatékony egyszerű változókhoz (számolás, flag-ek, logikai értékek)
std::mutex akkor kell, ha összetettebb kritikus szakaszokat védesz (pl. több változó módosítása együtt)

📦 Mikor használd?

Használj std::atomic-ot ha: - Egyszerű típusokat akarsz biztonságosan módosítani több szálból - A cél a minimális költségű szinkronizáció - Szükség van nagy teljesítményre, és kerülni akarod a mutex-ek miatti leállásokat

🧮 Speciális funkciók

A std::atomic nem csak egyszerű increment/decrement műveletekre jó:

compare_exchange_weak / compare_exchange_strong

➤ Ezek lehetővé teszik az úgynevezett “lock-free” algoritmusokat (pl. várólista nélküli queue, stack)

memory_order enum

➤ Finoman szabályozható vele a memóriahozzáférés sorrendje (ez haladó téma, pl. memory_order_relaxed, memory_order_acquire stb.)

📉 Hátrányai is vannak?

Nem minden típusra működik – pl. nem használható közvetlenül komplex objektumokkal (std::string, std::vector).
Ha túl bonyolult logikát akarsz atomizálni, akkor inkább std::mutex kell.
Lock-free ≠ bug-free 😄 — még mindig nagyon körültekintően kell használni!

🧾 Összefoglalás

Előnyök ✅	Hátrányok ⚠️
Gyors, hatékony	Csak egyszerű típusokhoz jó
Nincs szükség mutex-re	Bonyolult használat esetén kockázatos
Thread-safe műveletek	Nem helyettesíti mindenre a `mutex`-et
Könnyű implementálni számlálót, flag-et	Lock-free algoritmusok nehezen érthetők

További információk

std::atomic - Szótár.net (en-hu)
std::atomic - Sztaki (en-hu)
std::atomic - Merriam–Webster
std::atomic - Cambridge
std::atomic - WordNet
std::atomic - Яндекс (en-ru)
std::atomic - Google (en-hu)
std::atomic - Wikidata
std::atomic - Wikipédia (angol)