CKTIS / C++
Atomowy odczyt `std::shared_ptr` z jawnym porządkiem pamięci
W C++23 to przestarzałe przeciążenie atomowo kopiuje `std::shared_ptr` i pozwala jawnie wybrać porządek pamięci odczytu.
Wersja: ISO C++23; implementation support may vary
Składnia
// ISO C++23 — declared in <memory>
namespace std {
template<class T>
shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order order);
}
// For std::shared_ptr<T> slot:
auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);To przeciążenie funkcji wolnostojącej std::atomic_load_explicit jest deklarowane w <memory>. Przekaż &slot, czyli adres istniejącego obiektu std::shared_ptr<T>, a nie adres obiektu wskazywanego ani adres std::atomic<T>. Funkcja nie zgłasza wyjątków i zwraca kopię std::shared_ptr<T> przez wartość. Kopia zachowuje udział we współwłasności, jeśli odczytany wskaźnik taki udział miał. Przekazanie nullptr jako adresu slot powoduje niezdefiniowane zachowanie. Sam slot może jednak zawierać wskaźnik o wartości null; przed dereferencją sprawdź wynik, jeśli jest to możliwe.
W C++23 dozwolone porządki odczytu to std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire i std::memory_order_seq_cst. Użycie std::memory_order_release lub std::memory_order_acq_rel powoduje niezdefiniowane zachowanie. Wariant std::atomic_load(&slot) używa std::memory_order_seq_cst.
Jeśli odczyt z std::memory_order_acquire odczyta wartość zapisaną do tego samego slot przez std::atomic_store_explicit z std::memory_order_release, zapis synchronizuje się z odczytem. Inicjalizacja wykonana przed zapisem jest wtedy widoczna dla kodu wykonywanego po odczycie. Dodatkowa bariera std::atomic_thread_fence(std::memory_order_release) przed tym zapisem nie jest potrzebna do tej publikacji. Odczyt z std::memory_order_relaxed nadal jest atomowy, ale sam nie zapewnia tej synchronizacji.
Jeśli kilka wątków uzyskuje dostęp do tego samego slot i co najmniej jeden z nich może go modyfikować, nie mieszaj operacji tego API ze zwykłym kopiowaniem, przypisywaniem ani wywoływaniem reset() na tym obiekcie, chyba że dostęp jest osobno synchronizowany. Na przykład zwykłe przypisanie lub wywołanie reset() w jednym wątku może spowodować wyścig danych z atomowym odczytem w innym. Atomowy odczyt nie chroni późniejszych zmian wskazywanego obiektu i nie ma gwarancji, że obywa się bez blokad. Przeciążenie wprowadzono w C++11, oznaczono jako przestarzałe w C++20, zachowano w C++23 i usunięto ze standardu C++26. W nowym kodzie używaj std::atomic<std::shared_ptr<T>> oraz metod load(order) i store(value, order).
Przykłady
#include <atomic>
#include <iostream>
#include <memory>
int main() {
std::shared_ptr<const int> slot;
std::atomic_store_explicit(&slot, std::make_shared<const int>(42),
std::memory_order_release);
const auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);
std::atomic_store_explicit(&slot, std::shared_ptr<const int>{},
std::memory_order_relaxed);
std::cout << *snapshot << '\n';
}Wynik
42
Program jednowątkowy wypisuje `42`, ponieważ `snapshot` nadal współdzieli własność po wyczyszczeniu `slot`. Pokazuje składnię i czas życia, a nie synchronizację między wątkami.
Powiązane lekcje
- C++ · Lekcja 37 · Zaawansowany · Wersja: 3
Źródła
- C++23 final working draft (N4950) — shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- WG21 P2869R0 — Remove Deprecated shared_ptr Atomic Access APIs From C++26
- C++ working draft — Annex D compatibility changes from ISO C++ 2023 [diff.cpp23.depr]
- 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]