Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

std::atomic_thread_fence — sinkronizacija pomoću memorijskih ograda

std::atomic_thread_fence uspostavlja ograničenja redoslijeda pristupa memoriji bez čitanja ili zapisivanja određenog objekta. Sinkronizacija među dretvama zahtijeva prikladno povezane atomske operacije; same ograde nisu dovoljne.

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

Sintaksa

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

std::atomic_thread_fence(order) iz <atomic> vraća void i ne izbacuje iznimke. Ograda ne djeluje na određeni atomski objekt. Nije zaključavanje niti bezuvjetna naredba za „pražnjenje predmemorije“.

U C++23 std::memory_order_relaxed nema učinka. I std::memory_order_consume i std::memory_order_acquire stvaraju ogradu acquire. std::memory_order_release stvara ogradu release, a std::memory_order_acq_rel ogradu s oba svojstva. std::memory_order_seq_cst stvara sekvencijalno konzistentnu ogradu acquire i release.

U primjeru zapis u payload prethodi ogradi release, nakon koje slijedi atomski zapis u ready. Čitanje ready koje iz tog zapisa vidi true prethodi ogradi acquire. Taj lanac sinkronizira ograde i osigurava da se zapis u payload dogodi prije njegova čitanja: rezultat je 42, bez utrke podataka. Dodavanje ograda bez te atomske veze ne štiti obične podatke.

Ograda release može se povezati i s čitanjem acquire, ili zapis release s ogradom acquire, ako postoji potrebna veza reads-from. std::atomic_signal_fence ograničava redoslijed samo između dretve i rukovatelja signalom koji se izvršava u istoj dretvi. Navedeni izvor razvojni je nacrt standarda, a ne konačni tekst C++23.

Primjeri

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

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