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

CKTIS / C++

Atomický zápis std::shared_ptr s explicitním uspořádáním paměti

Starší přetížení zveřejňuje std::shared_ptr zápisem release a umožňuje jeho převzetí čtením acquire. V C++23 ještě existuje; pro nový kód je vhodnější std::atomic<std::shared_ptr<T>>.

Verze: ISO C++23; implementation support may vary

Syntaxe

#include <atomic>
#include <memory>

namespace std {
    template<class T>
    void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> desired,
                               memory_order order);
}

std::atomic_store_explicit(shared_ptr) označuje přetížení volné funkce z <memory>, které přijímá adresu běžného std::shared_ptr<T>, nikoli adresu std::atomic<T>. Atomicky nahradí *p hodnotou parametru desired předaného hodnotou, jako by provedlo p->swap(desired), a vrací void. p musí ukazovat na živý objekt, ale ukládaný shared_ptr smí být prázdný. Operace nemusí být bezzámková.

Při souběžném použití nekombinuj tyto funkce s přímým čtením, přiřazením ani voláním reset() u téže sdílené instance. std::atomic_load_explicit vrací samostatný shared_ptr hodnotou. Kopie mohou sdílet řídicí blok a udržovat spravovaný objekt naživu, ale nezabrání datovým závodům při přístupu k jeho měnitelnému obsahu.

Pokud čtení s std::memory_order_acquire načte hodnotu zapsanou zápisem s std::memory_order_release, zápis se synchronizuje se čtením. Inicializace před zápisem je pak viditelná pro kód po čtení. std::atomic_thread_fence(std::memory_order_release) těsně před tímto zápisem je v tomto vzoru nadbytečná. std::memory_order_relaxed zachovává atomicitu, ale sama takové zveřejnění nezaručuje. V C++23 starší zápis výslovně zakazuje acquire a acq_rel, starší čtení release a acq_rel; porušení těchto podmínek vede k nedefinovanému chování.

Tato volná přetížení byla zavedena v C++11, označena za zastaralá v C++20 a odstraněna v C++26. Stále jsou součástí C++23; podpora se může lišit podle implementace. V novém kódu používej std::atomic<std::shared_ptr<T>> a jeho členské funkce store a load.

Příklady

#include <atomic>
#include <iostream>
#include <memory>
#include <thread>

struct Config {
    int limit;
};

int main() {
    std::shared_ptr<const Config> published;
    std::thread publisher([&] {
        auto next = std::make_shared<const Config>(Config{42});
        std::atomic_store_explicit(&published, next, std::memory_order_release);
    });

    std::shared_ptr<const Config> snapshot;
    while (!(snapshot = std::atomic_load_explicit(
                 &published, std::memory_order_acquire))) {
        std::this_thread::yield();
    }

    std::cout << snapshot->limit << '\n';
    publisher.join();
}

Výsledek

42

Hlavní vlákno opakuje čtení acquire, dokud nezíská neprázdnou kopii. Vypíše `42` před `join()`; konfiguraci zpřístupňuje dvojice release/acquire, nikoli `join()`.

Související lekce

  • C++ · Lekce 37 · Pokročilá · Verze: 3

Zdroje