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

CKTIS / C++

Vrstni red pomnilnika pri atomskih operacijah

Konstante tipa std::memory_order določajo sinhronizacijo in vrstni red atomskih operacij. Spoznajte razlike med relaxed, release, acquire, acq_rel in seq_cst ter kako lahko atomska zastavica varno objavi običajne podatke.

Različica: C++23; repository compiler flag, production runtime not attested

Sintaksa

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

Konstante iz <atomic> tipa std::memory_order izberejo pravila za vrstni red; običajnih spremenljivk ne naredijo atomskih. Imena, kot je std::memory_order_relaxed, ustrezajo vrednostim, kot je std::memory_order::relaxed. Ta pravila veljajo za C++23; eel.is gosti spreminjajoči se osnutek, ne nespremenljive izdaje C++23.

std::memory_order_relaxed ohrani atomarnost, vendar sam ne sinhronizira dostopa do drugih podatkov med nitmi. std::memory_order_release lahko objavi prejšnje zapise. std::memory_order_acquire se sinhronizira z operacijo release na istem atomskem objektu, kadar prebere njeno vrednost ali vrednost iz njene release sekvence. Sama uporaba obeh imen ne zadostuje.

std::memory_order_acq_rel združi acquire in release v operaciji branje–sprememba–zapis, na primer exchange. std::memory_order_seq_cst zagotovi ustrezne lastnosti acquire/release in en sam popoln vrstni red operacij seq_cst. Ne odpravi podatkovnih tekmovanj in šibkejših operacij ne vključi samodejno v ta vrstni red.

Za load so med temi petimi konstantami veljavne relaxed, acquire in seq_cst; za store pa relaxed, release in seq_cst. acq_rel ni veljaven za navaden load ali store. Privzeti vrstni red teh metod je seq_cst. Oslabitev vrstnega reda zahteva utemeljitev pravilnosti, ne le meritev hitrosti.

V primeru se branje true z acquire sinhronizira z zapisom release, zato se payload = 42 zgodi pred njegovim branjem v razmerju happens-before. Zamenjava obeh vrstnih redov z relaxed bi odstranila to jamstvo in povzročila podatkovno tekmovanje pri payload. Zanka aktivno čaka; izhod po zaključku je določen, čas čakanja pa nima določene zgornje meje.

Primeri

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

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