Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

std::atomic_thread_fence — sinhronizacija z uporabo pomnilniških pregrad

std::atomic_thread_fence določa omejitve vrstnega reda dostopov do pomnilnika, ne da bi bral ali zapisoval določen objekt. Sinhronizacija med nitmi zahteva ustrezno povezane atomske operacije; same pregrade ne zadostujejo.

Različica: 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> vrne void in ne sproži izjem. Pregrada ne deluje na določen atomski objekt. Ni zaklep in tudi ne brezpogojni ukaz za »izpraznitev predpomnilnika«.

V C++23 std::memory_order_relaxed nima učinka. Tako std::memory_order_consume kot std::memory_order_acquire ustvarita pregrado acquire. std::memory_order_release ustvari pregrado release, std::memory_order_acq_rel pa pregrado z obema lastnostma. std::memory_order_seq_cst ustvari zaporedno skladno pregrado z lastnostma acquire in release.

V primeru je zapis v payload pred pregrado release, za njo pa sledi atomski zapis v ready. Branje ready, ki iz tega zapisa vidi true, je pred pregrado acquire. Ta veriga sinhronizira pregradi in zagotovi, da se zapis v payload zgodi pred njegovim branjem: rezultat je 42, brez podatkovne tekme. Dodajanje pregrad brez te atomske povezave ne zaščiti običajnih podatkov.

Pregrado release je mogoče povezati tudi z branjem acquire ali zapis release s pregrado acquire, če obstaja zahtevana povezava reads-from. std::atomic_signal_fence omejuje vrstni red samo med nitjo in signalnim obravnavalnikom, ki se izvaja v isti niti. Navedeni vir je razvijajoči se osnutek standarda, ne nespremenjeno besedilo C++23.

Primeri

#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

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri