Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Atomsko spremanje std::shared_ptr s izričitim memorijskim poretkom

Starije preopterećenje objavljuje std::shared_ptr upisom release koji se povezuje s čitanjem acquire. Još je dio C++23; u novom kodu radije koristi std::atomic<std::shared_ptr<T>>.

Verzija: 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čava preopterećenje slobodne funkcije iz <memory> koje prima adresu običnog std::shared_ptr<T>, a ne adresu std::atomic<T>. Atomski zamjenjuje *p parametrom desired proslijeđenim po vrijednosti, kao da izvodi p->swap(desired), i vraća void. p mora pokazivati na živ objekt, ali shared_ptr koji se sprema može biti prazan. Rad bez zaključavanja nije zajamčen.

Pri istodobnoj uporabi ne kombiniraj te funkcije s izravnim čitanjem, dodjelom ili pozivom reset() na istoj dijeljenoj instanci. std::atomic_load_explicit vraća zaseban shared_ptr po vrijednosti. Kopije mogu dijeliti kontrolni blok i održavati upravljani objekt na životu, ali ne sprječavaju utrke podataka na njegovu promjenjivom sadržaju.

Ako čitanje s std::memory_order_acquire pročita vrijednost zapisanu upisom s std::memory_order_release, upis se sinkronizira s čitanjem. Inicijalizacija prije upisa tada je vidljiva kodu nakon čitanja. std::atomic_thread_fence(std::memory_order_release) neposredno prije tog upisa suvišan je u ovom obrascu. std::memory_order_relaxed čuva atomskost, ali sam ne daje to jamstvo objave. U C++23 stariji upis izričito zabranjuje acquire i acq_rel, a starije čitanje zabranjuje release i acq_rel; kršenje tih preduvjeta uzrokuje nedefinirano ponašanje.

Ova preopterećenja slobodnih funkcija uvedena su u C++11, označena zastarjelima u C++20 i uklonjena u C++26. Još su dio C++23; podrška se može razlikovati ovisno o implementaciji. U novom kodu koristi std::atomic<std::shared_ptr<T>> i njegove članske funkcije store i load.

Primjeri

#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 dretva ponavlja čitanje acquire dok ne dobije nepraznu kopiju. Ispisuje `42` prije `join()`; konfiguraciju objavljuje par release/acquire, a ne `join()`.

Povezane lekcije

  • C++ · Lekcija 37 · Napredno · Verzija: 3

Izvori