Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Memorijski redoslijedi atomskih operacija

Konstante tipa std::memory_order određuju sinkronizaciju i redoslijed atomskih operacija. Saznajte po čemu se razlikuju relaxed, release, acquire, acq_rel i seq_cst te kako atomska zastavica može sigurno objaviti obične podatke.

Verzija: C++23; repository compiler flag, production runtime not attested

Sintaksa

#include <atomic>
a.load(std::memory_order_acquire);
a.store(value, std::memory_order_release);
a.fetch_add(1, std::memory_order_relaxed);
a.exchange(value, std::memory_order_acq_rel);
a.load(std::memory_order_seq_cst);

Konstante iz <atomic> tipa std::memory_order odabiru pravila redoslijeda; obične varijable ne čine atomskima. Nazivi poput std::memory_order_relaxed odgovaraju vrijednostima poput std::memory_order::relaxed. Ova pravila vrijede za C++23; eel.is sadrži nacrt koji se razvija, a ne nepromjenjivu objavu C++23.

std::memory_order_relaxed čuva atomarnost, ali sam po sebi ne sinkronizira pristup drugim podacima između dretvi. std::memory_order_release može objaviti ranije zapise. std::memory_order_acquire sinkronizira se s operacijom release na istom atomskom objektu kada pročita njezinu vrijednost ili vrijednost iz njezina release niza. Nije dovoljno samo upotrijebiti oba naziva.

std::memory_order_acq_rel spaja acquire i release u operaciji čitanja–izmjene–pisanja, kao što je exchange. std::memory_order_seq_cst pruža primjenjiva svojstva acquire/release te jedan potpuni redoslijed operacija seq_cst. Ne uklanja utrke podataka niti automatski uključuje slabije operacije u taj redoslijed.

Za load su među ovih pet konstanti valjani relaxed, acquire i seq_cst; za store valjani su relaxed, release i seq_cst. acq_rel nije valjan za običan load ili store. Zadani redoslijed tih metoda je seq_cst. Slabljenje redoslijeda zahtijeva obrazloženje ispravnosti, a ne samo mjerenje brzine.

U primjeru se acquire čitanje vrijednosti true sinkronizira s release zapisom, pa payload = 42 prethodi njegovu čitanju u odnosu happens-before. Zamjena oba redoslijeda s relaxed uklonila bi to jamstvo i uzrokovala utrku podataka na payload. Petlja aktivno čeka; izlaz po završetku je određen, ali vrijeme čekanja nema fiksnu gornju granicu.

Primjeri

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

int main() {
    int payload = 0;
    std::atomic<bool> ready{false};

    std::thread producer([&] {
        payload = 42;
        ready.store(true, std::memory_order_release);
    });

    while (!ready.load(std::memory_order_acquire)) {
        std::this_thread::yield();
    }
    std::cout << payload << '\n';
    producer.join();
}

Rezultat

42

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori