Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Pořadí paměti u atomických operací

Konstanty typu std::memory_order určují synchronizaci a řazení atomických operací. Zjistěte, jak se liší relaxed, release, acquire, acq_rel a seq_cst a jak může atomický příznak bezpečně zpřístupnit běžná data.

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

Syntaxe

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

Konstanty z <atomic> typu std::memory_order vybírají pravidla řazení; běžné proměnné nedělají atomickými. Názvy jako std::memory_order_relaxed odpovídají hodnotám jako std::memory_order::relaxed. Tato pravidla platí pro C++23; eel.is nabízí průběžně se měnící návrh, nikoli neměnné vydání C++23.

std::memory_order_relaxed zachovává atomicitu, ale samo o sobě nesynchronizuje přístup k jiným datům mezi vlákny. std::memory_order_release může zpřístupnit dřívější zápisy. std::memory_order_acquire se synchronizuje s operací release nad stejným atomickým objektem, pokud čte její hodnotu nebo hodnotu z její release sekvence. Pouhé použití obou názvů nestačí.

std::memory_order_acq_rel spojuje acquire a release v operaci čtení–modifikace–zápis, například exchange. std::memory_order_seq_cst poskytuje příslušné vlastnosti acquire/release a také jediné úplné pořadí operací seq_cst. Neodstraňuje datové závody ani do tohoto pořadí automaticky nezařazuje slabší operace.

Pro load jsou z těchto pěti konstant platné relaxed, acquire a seq_cst; pro store relaxed, release a seq_cst. acq_rel není platné pro samotné load ani store. Výchozím pořadím těchto metod je seq_cst. Oslabení pořadí vyžaduje zdůvodnění správnosti, nejen měření rychlosti.

V příkladu se čtení true s pořadím acquire synchronizuje se zápisem release, takže payload = 42 předchází jeho čtení ve vztahu happens-before. Nahrazení obou pořadí hodnotou relaxed by tuto záruku odstranilo a způsobilo datový závod na payload. Smyčka aktivně čeká; výstup po dokončení je daný, ale doba čekání nemá pevnou horní mez.

Příklady

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

Výsledek

42

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje