Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Porządki pamięci operacji atomowych

Stałe std::memory_order określają synchronizację i porządkowanie operacji atomowych. Poznaj różnice między relaxed, release, acquire, acq_rel i seq_cst oraz sposób bezpiecznego opublikowania zwykłych danych przez flagę atomową.

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

Składnia

#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);

Stałe z <atomic> typu std::memory_order wybierają reguły porządkowania; nie włączają atomowości zwykłych zmiennych. Nazwy std::memory_order_relaxed itd. odpowiadają wartościom std::memory_order::relaxed itd. Poniższe zasady dotyczą C++23; eel.is udostępnia rozwijany szkic, a nie zamrożoną publikację C++23.

std::memory_order_relaxed zachowuje atomowość, ale samo nie synchronizuje dostępu do innych danych między wątkami. std::memory_order_release służy m.in. do publikacji wcześniejszych zapisów. std::memory_order_acquire synchronizuje się z operacją release na tym samym obiekcie atomowym, jeżeli odczytuje jej wartość lub wartość z zapoczątkowanej przez nią sekwencji release. Sama para nazw nie wystarcza.

std::memory_order_acq_rel łączy acquire i release w operacji odczyt–modyfikacja–zapis, np. exchange. std::memory_order_seq_cst zapewnia odpowiednie właściwości acquire/release oraz jeden wspólny porządek całkowity operacji seq_cst. Nie usuwa wyścigów danych ani nie włącza automatycznie słabszych operacji do tego porządku.

Dla load spośród tych pięciu stałych dozwolone są relaxed, acquire i seq_cst; dla store: relaxed, release i seq_cst. acq_rel nie nadaje się do samego load ani store. Domyślnym porządkiem tych metod jest seq_cst. Osłabienie porządku wymaga uzasadnienia poprawności, nie tylko pomiaru szybkości.

W przykładzie odczyt true przez acquire synchronizuje się z zapisem release, więc zapis payload = 42 poprzedza jego odczyt w relacji happens-before. Zamiana obu porządków na relaxed usunęłaby tę gwarancję i spowodowała wyścig danych na payload. Pętla aktywnie czeka; wynik po zakończeniu jest ustalony, ale czas oczekiwania nie ma ustalonej granicy.

Przykłady

#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();
}

Wynik

42

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła