CKTIS / C++
Atomsko shranjevanje std::shared_ptr z izrecnim pomnilniškim vrstnim redom
Starejša preobremenitev objavi std::shared_ptr z zapisom release, ki se poveže z branjem acquire. V C++23 še obstaja; za novo kodo raje uporabi std::atomic<std::shared_ptr<T>>.
Različica: ISO C++23; implementation support may vary
Sintaksa
#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) označuje preobremenitev proste funkcije iz <memory>, ki sprejme naslov navadnega std::shared_ptr<T>, ne naslova std::atomic<T>. Atomsko nadomesti *p s po vrednosti podanim parametrom desired, kakor da bi izvedla p->swap(desired), in vrne void. p mora kazati na živ objekt, shranjeni shared_ptr pa je lahko prazen. Delovanje brez zaklepanja ni zagotovljeno.
Pri sočasni uporabi teh funkcij ne mešaj z neposrednim branjem, prirejanjem ali klicem reset() na istem deljenem primerku. std::atomic_load_explicit po vrednosti vrne ločen shared_ptr. Kopije si lahko delijo nadzorni blok in ohranjajo upravljani objekt pri življenju, vendar ne preprečujejo podatkovnih tekem pri dostopu do njegove spremenljive vsebine.
Če branje z std::memory_order_acquire prebere vrednost, zapisano z std::memory_order_release, se zapis sinhronizira z branjem. Inicializacija pred zapisom je tako vidna kodi po branju. std::atomic_thread_fence(std::memory_order_release) tik pred tem zapisom je v tem vzorcu odveč. std::memory_order_relaxed ohrani atomskost, sam pa ne zagotovi takšne objave. V C++23 starejši zapis izrecno prepoveduje acquire in acq_rel, starejše branje pa release in acq_rel; kršitev teh predpogojev povzroči nedefinirano vedenje.
Te preobremenitve prostih funkcij so bile uvedene v C++11, označene kot zastarele v C++20 in odstranjene v C++26. Še vedno so del C++23; podpora se lahko razlikuje med implementacijami. V novi kodi uporabi std::atomic<std::shared_ptr<T>> in njegovi članski funkciji store in load.
Primeri
#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();
}Rezultat
42
Glavna nit ponavlja branje acquire, dokler ne dobi neprazne kopije. Pred `join()` izpiše `42`; konfiguracijo objavi par release/acquire, ne `join()`.
Povezane lekcije
- C++ · Lekcija 37 · Napredna · Različica: 3
Viri
- 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]