Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

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