CKTIS / C++
Scrittura atomica di std::shared_ptr con ordine di memoria esplicito
Il vecchio overload pubblica uno std::shared_ptr con una scrittura release abbinata a una lettura acquire. È ancora presente in C++23; nel nuovo codice preferisci std::atomic<std::shared_ptr<T>>.
Versione: ISO C++23; implementation support may vary
Sintassi
#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) indica l’overload della funzione non membro in <memory> che riceve l’indirizzo di un normale std::shared_ptr<T>, non quello di uno std::atomic<T>. Sostituisce atomicamente *p con il parametro desired passato per valore, come se eseguisse p->swap(desired), e restituisce void. p deve puntare a un oggetto ancora in vita, ma lo shared_ptr da memorizzare può essere vuoto. Non è garantito che l’operazione sia priva di lock.
Durante l’uso concorrente, non combinare queste funzioni con letture dirette, assegnazioni o chiamate a reset() sulla stessa istanza condivisa. std::atomic_load_explicit restituisce per valore uno shared_ptr distinto. Le copie possono condividere il blocco di controllo e mantenere in vita l’oggetto gestito, ma non impediscono le corse sui dati del suo contenuto modificabile.
Quando una lettura std::memory_order_acquire legge il valore scritto da una scrittura std::memory_order_release, la scrittura si sincronizza con la lettura. L’inizializzazione precedente alla scrittura è quindi visibile al codice dopo la lettura. Una std::atomic_thread_fence(std::memory_order_release) immediatamente prima di quella scrittura è ridondante in questo schema. std::memory_order_relaxed preserva l’atomicità, ma da solo non offre questa garanzia di pubblicazione. In C++23 la vecchia scrittura vieta esplicitamente acquire e acq_rel, mentre la vecchia lettura vieta release e acq_rel; violare queste precondizioni comporta un comportamento indefinito.
Questi overload non membro sono stati introdotti in C++11, deprecati in C++20 e rimossi in C++26. Fanno ancora parte di C++23; il supporto può variare a seconda dell’implementazione. Nel nuovo codice usa std::atomic<std::shared_ptr<T>> e le sue funzioni membro store e load.
Esempi
#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();
}Risultato
42
Il thread principale ripete la lettura acquire finché non ottiene una copia non vuota. Stampa `42` prima di `join()`: è la coppia release/acquire a pubblicare la configurazione, non `join()`.
Lezioni correlate
- C++ · Lezione 37 · Avanzato · Versione: 3
Fonti
- 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]