KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Geheugenordeningen voor atomaire bewerkingen

Constanten van het type std::memory_order bepalen de synchronisatie en ordening van atomaire bewerkingen. Leer wat het verschil is tussen relaxed, release, acquire, acq_rel en seq_cst, en hoe een atomair vlaggetje gewone gegevens veilig kan publiceren.

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

Syntax

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

Constanten uit <atomic> van het type std::memory_order kiezen ordeningsregels; ze maken gewone variabelen niet atomair. Namen zoals std::memory_order_relaxed komen overeen met waarden zoals std::memory_order::relaxed. Deze regels gelden voor C++23; eel.is bevat een veranderlijk ontwerp, geen onveranderlijke C++23-publicatie.

std::memory_order_relaxed behoudt atomiciteit, maar synchroniseert op zichzelf geen toegang tot andere gegevens tussen threads. std::memory_order_release kan eerdere schrijfacties publiceren. std::memory_order_acquire synchroniseert met een release-bewerking op hetzelfde atomaire object wanneer deze de waarde van die bewerking leest of een waarde uit de bijbehorende release-sequentie. Alleen beide namen gebruiken is niet voldoende.

std::memory_order_acq_rel combineert acquire en release in een read-modify-write-bewerking, zoals exchange. std::memory_order_seq_cst biedt de toepasselijke acquire-/release-eigenschappen plus één totale ordening van seq_cst-bewerkingen. Het verhelpt geen data races en neemt zwakkere bewerkingen niet automatisch in die ordening op.

Voor load zijn relaxed, acquire en seq_cst geldig uit deze vijf constanten; voor store zijn dat relaxed, release en seq_cst. acq_rel is niet geldig voor een gewone load of store. Deze methoden gebruiken standaard seq_cst. Een zwakkere ordening vereist een onderbouwing van de correctheid, niet alleen een snelheidsmeting.

In het voorbeeld synchroniseert de acquire-lezing van true met de release-schrijfactie. Daardoor gebeurt payload = 42 vóór het lezen ervan volgens de happens-before-relatie. Als je beide ordeningen door relaxed vervangt, verdwijnt die garantie en ontstaat er een data race op payload. De lus wacht actief; de uitvoer na afloop ligt vast, maar de wachttijd heeft geen vaste bovengrens.

Voorbeelden

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

Resultaat

42

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen