CKTIS / C++
Atómový zápis std::shared_ptr s explicitným usporiadaním pamäte
Staršie preťaženie zverejňuje std::shared_ptr zápisom release, ktorý nadväzuje na čítanie acquire. V C++23 ešte existuje; v novom kóde uprednostni std::atomic<std::shared_ptr<T>>.
Verzia: ISO C++23; implementation support may vary
Syntax
#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 preťaženie voľnej funkcie z <memory>, ktoré prijíma adresu obyčajného std::shared_ptr<T>, nie adresu std::atomic<T>. Atómovo nahradí *p parametrom desired odovzdaným hodnotou, akoby vykonalo p->swap(desired), a vracia void. p musí ukazovať na živý objekt, no ukladaný shared_ptr môže byť prázdny. Operácia nemusí byť bezzámková.
Pri súbežnom používaní nekombinuj tieto funkcie s priamym čítaním, priradením ani volaním reset() na tej istej zdieľanej inštancii. std::atomic_load_explicit vracia samostatný shared_ptr hodnotou. Kópie môžu zdieľať riadiaci blok a udržiavať spravovaný objekt nažive, no nezabraňujú dátovým pretekom pri prístupe k jeho meniteľnému obsahu.
Ak čítanie s std::memory_order_acquire načíta hodnotu zapísanú zápisom s std::memory_order_release, zápis sa synchronizuje s čítaním. Inicializácia pred zápisom je potom viditeľná pre kód po čítaní. std::atomic_thread_fence(std::memory_order_release) tesne pred týmto zápisom je v tomto vzore nadbytočná. std::memory_order_relaxed zachováva atómovosť, no sama nezaručuje takéto zverejnenie. V C++23 starší zápis výslovne zakazuje acquire a acq_rel a staršie čítanie zakazuje release a acq_rel; porušenie týchto podmienok spôsobuje nedefinované správanie.
Tieto preťaženia voľných funkcií boli zavedené v C++11, označené za zastarané v C++20 a odstránené v C++26. Stále sú súčasťou C++23; podpora sa môže líšiť podľa implementácie. V novom kóde použi std::atomic<std::shared_ptr<T>> a jeho členské funkcie store a load.
Prí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ýsledok
42
Hlavné vlákno opakuje čítanie acquire, kým nedostane neprázdnu kópiu. Vypíše `42` pred `join()`; konfiguráciu zverejňuje dvojica release/acquire, nie `join()`.
Súvisiace lekcie
- C++ · Lekcia 37 · Pokročilá · Verzia: 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]