CKTIS / C++
Caricamento atomico di `std::shared_ptr` con ordine di memoria esplicito
In C++23, questo overload deprecato copia atomicamente uno `std::shared_ptr` e permette di scegliere l’ordine di memoria del caricamento.
Versione: ISO C++23; implementation support may vary
Sintassi
// 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);Questo overload della funzione non membro std::atomic_load_explicit è dichiarato in <memory>. Passa &slot, ossia l’indirizzo di un oggetto std::shared_ptr<T> ancora in vita, non quello dell’oggetto puntato né quello di uno std::atomic<T>. La funzione restituisce per valore una copia di tipo std::shared_ptr<T> senza lanciare eccezioni. Se il valore letto partecipava alla proprietà condivisa, la copia mantiene tale partecipazione. Passare un indirizzo nullo per slot causa un comportamento indefinito. Il puntatore contenuto in slot, invece, può essere nullo: se è possibile, controlla il risultato prima di dereferenziarlo.
In C++23 gli ordini di caricamento validi sono std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire e std::memory_order_seq_cst. Usare std::memory_order_release o std::memory_order_acq_rel causa un comportamento indefinito. La forma breve std::atomic_load(&slot) usa std::memory_order_seq_cst.
Se un caricamento con semantica di acquisizione legge il valore scritto nello stesso slot da std::atomic_store_explicit con std::memory_order_release, la scrittura si sincronizza con la lettura. L’inizializzazione precedente alla scrittura è quindi visibile al codice eseguito dopo la lettura. Una barriera separata std::atomic_thread_fence(std::memory_order_release) prima di quella scrittura è ridondante per questa pubblicazione. Un caricamento con std::memory_order_relaxed rimane atomico, ma da solo non fornisce questa sincronizzazione.
Se più thread accedono allo stesso slot e almeno uno può modificarlo, non mescolare questa API con copie ordinarie, assegnazioni o chiamate a reset() su quell’oggetto, a meno che gli accessi non siano sincronizzati separatamente. Per esempio, un’assegnazione ordinaria o una chiamata a reset() in un thread può causare una corsa sui dati con un caricamento atomico in un altro thread. Il caricamento atomico non protegge le modifiche successive all’oggetto puntato e non è garantito che sia privo di lock. L’overload è stato introdotto in C++11, deprecato in C++20, mantenuto in C++23 e rimosso dallo standard C++26. Per il codice nuovo, usa std::atomic<std::shared_ptr<T>> con load(order) e store(value, order).
Esempi
#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';
}Risultato
42
Il programma a thread singolo stampa `42` perché `snapshot` mantiene la proprietà condivisa dopo lo svuotamento di `slot`. Mostra la sintassi e la durata di vita, non la sincronizzazione tra thread.
Lezioni correlate
- C++ · Lezione 37 · Avanzato · Versione: 3
Fonti
- 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]