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
- P2869R0 — Remove Deprecated Atomic Access APIs From C++26 (includes the legacy wording)
- C++23 working draft N4950 — Deprecated shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- C++ working draft — Order and consistency [atomics.order]
- C++ working draft — Fences [atomics.fences]
- C++ working draft — Partial specialization for shared_ptr [util.smartptr.atomic.shared]