CKTIS / C++
Atomowy zapis std::shared_ptr z jawnym porządkiem pamięci
Starsze przeciążenie pozwala opublikować std::shared_ptr zapisem release i odebrać go odczytem acquire. W C++23 nadal istnieje, ale do nowego kodu wybieraj std::atomic<std::shared_ptr<T>>.
Wersja: ISO C++23; implementation support may vary
Składnia
#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) oznacza wolną funkcję z <memory>, która przyjmuje adres zwykłego std::shared_ptr<T>, a nie adres std::atomic<T>. Atomowo zastępuje *p przekazaną przez wartość kopią wskaźnika desired lub wartością przeniesioną do tego parametru, tak jak przez p->swap(desired), i zwraca void. p musi wskazywać na istniejący obiekt, lecz zapisywany shared_ptr może być pusty. Nie zakładaj, że operacja nie używa blokad.
Nie mieszaj dostępu przez te funkcje z bezpośrednim odczytem, przypisaniem ani reset() tego samego współdzielonego egzemplarza podczas współbieżnego użycia. std::atomic_load_explicit zwraca osobny shared_ptr przez wartość. Takie kopie mogą korzystać z tego samego bloku kontrolnego i podtrzymują czas życia zarządzanego obiektu, ale nie chronią przed wyścigami danych przy modyfikowaniu jego zawartości.
Jeśli odczyt z std::memory_order_acquire pobierze wartość zapisaną z std::memory_order_release, zapis synchronizuje się z odczytem. Inicjalizacja poprzedzająca zapis staje się widoczna dla kodu po odczycie. std::atomic_thread_fence(std::memory_order_release) tuż przed tym zapisem jest w tym schemacie zbędna. std::memory_order_relaxed zachowuje atomowość, ale sama nie zapewnia takiej publikacji. W C++23 starsze przeciążenie zapisu wyklucza acquire i acq_rel, a przeciążenie odczytu wyklucza release i acq_rel; naruszenie tych warunków daje niezdefiniowane zachowanie.
Te wolne przeciążenia wprowadzono w C++11, uznano za przestarzałe w C++20 i usunięto w C++26. W C++23 nadal są częścią standardu; obsługa przez implementacje może się różnić. W nowym kodzie używaj std::atomic<std::shared_ptr<T>> oraz jego metod store i load.
Przykłady
#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();
}Wynik
42
Główny wątek ponawia odczyt acquire, dopóki nie otrzyma niepustej kopii. Wypisuje `42` przed `join()`; publikację zapewnia para release/acquire, nie `join()`.
Powiązane lekcje
- C++ · Lekcja 37 · Zaawansowany · Wersja: 3
Źródła
- 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]