Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Atómový zápis std::shared_ptr s explicitným usporiadaním pamäte

Staršie preťaženie zverejňuje std::shared_ptr zápisom release, ktorý nadväzuje na čítanie acquire. V C++23 ešte existuje; v novom kóde uprednostni std::atomic<std::shared_ptr<T>>.

Verzia: ISO C++23; implementation support may vary

Syntax

#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 preťaženie voľnej funkcie z <memory>, ktoré prijíma adresu obyčajného std::shared_ptr<T>, nie adresu std::atomic<T>. Atómovo nahradí *p parametrom desired odovzdaným hodnotou, akoby vykonalo p->swap(desired), a vracia void. p musí ukazovať na živý objekt, no ukladaný shared_ptr môže byť prázdny. Operácia nemusí byť bezzámková.

Pri súbežnom používaní nekombinuj tieto funkcie s priamym čítaním, priradením ani volaním reset() na tej istej zdieľanej inštancii. std::atomic_load_explicit vracia samostatný shared_ptr hodnotou. Kópie môžu zdieľať riadiaci blok a udržiavať spravovaný objekt nažive, no nezabraňujú dátovým pretekom pri prístupe k jeho meniteľnému obsahu.

Ak čítanie s std::memory_order_acquire načíta hodnotu zapísanú zápisom s std::memory_order_release, zápis sa synchronizuje s čítaním. Inicializácia pred zápisom je potom viditeľná pre kód po čítaní. std::atomic_thread_fence(std::memory_order_release) tesne pred týmto zápisom je v tomto vzore nadbytočná. std::memory_order_relaxed zachováva atómovosť, no sama nezaručuje takéto zverejnenie. V C++23 starší zápis výslovne zakazuje acquire a acq_rel a staršie čítanie zakazuje release a acq_rel; porušenie týchto podmienok spôsobuje nedefinované správanie.

Tieto preťaženia voľných funkcií boli zavedené v C++11, označené za zastarané v C++20 a odstránené v C++26. Stále sú súčasťou C++23; podpora sa môže líšiť podľa implementácie. V novom kóde použi std::atomic<std::shared_ptr<T>> a jeho členské funkcie store a load.

Príklady

#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();
}

Výsledok

42

Hlavné vlákno opakuje čítanie acquire, kým nedostane neprázdnu kópiu. Vypíše `42` pred `join()`; konfiguráciu zverejňuje dvojica release/acquire, nie `join()`.

Súvisiace lekcie

  • C++ · Lekcia 37 · Pokročilá · Verzia: 3

Zdroje