Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::atomic_thread_fence — synchronizacja za pomocą ogrodzeń pamięci

std::atomic_thread_fence ustanawia ograniczenia porządku pamięci bez odczytu ani zapisu wskazanego obiektu. Synchronizacja między wątkami wymaga odpowiednio powiązanych operacji atomowych; same ogrodzenia nie wystarczą.

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

Składnia

#include <atomic>
std::atomic_thread_fence(order); // order: std::memory_order; returns void

std::atomic_thread_fence(order) z <atomic> zwraca void i nie zgłasza wyjątków. Ogrodzenie nie operuje na konkretnym obiekcie atomowym. Nie jest blokadą ani poleceniem bezwarunkowego „opróżnienia pamięci podręcznej”.

W C++23 std::memory_order_relaxed nie daje żadnego efektu; zarówno std::memory_order_consume, jak i std::memory_order_acquire tworzą ogrodzenie acquire, std::memory_order_release — ogrodzenie release, a std::memory_order_acq_rel — ogrodzenie o obu właściwościach. std::memory_order_seq_cst tworzy sekwencyjnie spójne ogrodzenie acquire i release.

W przykładzie zapis payload poprzedza ogrodzenie release, po którym następuje atomowy zapis ready. Odczyt ready, który zobaczy true z tego zapisu, poprzedza ogrodzenie acquire. Ten łańcuch synchronizuje ogrodzenia i sprawia, że zapis payload zachodzi przed jego odczytem: wynikiem jest 42, bez wyścigu danych. Samo dodanie ogrodzeń bez takiego powiązania atomowego nie chroni zwykłych danych.

Można też łączyć ogrodzenie release z odczytem acquire albo zapis release z ogrodzeniem acquire, przy wymaganym powiązaniu odczytaną wartością. std::atomic_signal_fence ogranicza porządek tylko między wątkiem a obsługą sygnału wykonywaną w tym samym wątku. Podane źródło jest rozwijanym projektem standardu, a nie zamrożonym tekstem C++23.

Przykłady

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

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

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

    while (!ready.load(std::memory_order_relaxed)) {
        std::this_thread::yield();
    }
    std::atomic_thread_fence(std::memory_order_acquire);
    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