CKTIS / C++
Écriture atomique d’un std::shared_ptr avec un ordre mémoire explicite
L’ancienne surcharge publie un std::shared_ptr par une écriture release associée à une lecture acquire. Elle existe encore en C++23 ; préférez std::atomic<std::shared_ptr<T>> dans le nouveau code.
Version : ISO C++23; implementation support may vary
Syntaxe
#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) désigne la surcharge de la fonction non membre déclarée dans <memory> qui prend l’adresse d’un std::shared_ptr<T> ordinaire, et non celle d’un std::atomic<T>. Elle remplace atomiquement *p par le paramètre desired passé par valeur, comme si elle effectuait p->swap(desired), et renvoie void. p doit pointer vers un objet vivant, mais le shared_ptr à enregistrer peut être vide. L’absence de verrou n’est pas garantie.
En cas d’utilisation concurrente, ne mélangez pas ces fonctions avec une lecture directe, une affectation ou un appel à reset() sur la même instance partagée. std::atomic_load_explicit renvoie un shared_ptr distinct par valeur. Les copies peuvent partager un bloc de contrôle et maintenir l’objet géré en vie, mais elles n’empêchent pas les courses de données sur son contenu modifiable.
Lorsqu’une lecture std::memory_order_acquire lit la valeur écrite par une écriture std::memory_order_release, l’écriture se synchronise avec la lecture. L’initialisation qui précède l’écriture est alors visible pour le code exécuté après la lecture. Un std::atomic_thread_fence(std::memory_order_release) placé juste avant cette écriture est redondant dans ce schéma. std::memory_order_relaxed préserve l’atomicité, mais ne fournit pas à lui seul cette garantie de publication. En C++23, l’ancienne écriture interdit explicitement acquire et acq_rel, et l’ancienne lecture interdit release et acq_rel ; enfreindre ces préconditions entraîne un comportement indéfini.
Introduites en C++11, ces surcharges non membres ont été dépréciées en C++20 et supprimées en C++26. Elles font encore partie de C++23 ; leur prise en charge peut varier selon l’implémentation. Dans le nouveau code, utilisez std::atomic<std::shared_ptr<T>> et ses fonctions membres store et load.
Exemples
#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();
}Résultat
42
Le thread principal répète la lecture acquire jusqu’à obtenir une copie non vide. Il affiche `42` avant `join()` : c’est la paire release/acquire qui publie la configuration, pas `join()`.
Leçons associées
- C++ · Leçon 37 · Avancé · Version : 3
Sources
- 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]