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.