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

CKTIS / C++

Atómové načítanie `std::shared_ptr` s explicitným usporiadaním pamäte

V C++23 tento zastaraný variant funkcie atómovo kopíruje `std::shared_ptr` a umožňuje zvoliť usporiadanie pamäte pri načítaní.

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

Syntax

// ISO C++23 — declared in <memory>
namespace std {
    template<class T>
    shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order order);
}

// For std::shared_ptr<T> slot:
auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);

Tento variant voľnej funkcie std::atomic_load_explicit je deklarovaný v <memory>. Odovzdaj &slot, teda adresu objektu std::shared_ptr<T>, ktorého životnosť ešte trvá, nie adresu objektu, na ktorý ukazuje, ani adresu std::atomic<T>. Funkcia vracia kópiu typu std::shared_ptr<T> hodnotou a nevyhadzuje výnimky. Ak načítaná hodnota mala podiel na zdieľanom vlastníctve, kópia si ho zachová. Odovzdanie nulovej adresy pre slot spôsobí nedefinované správanie. Ukazovateľ uložený v slot však môže byť nulový; ak to prichádza do úvahy, pred dereferencovaním skontroluj výsledok.

V C++23 možno pri načítaní použiť std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire a std::memory_order_seq_cst. Použitie std::memory_order_release alebo std::memory_order_acq_rel vedie k nedefinovanému správaniu. Skrátený zápis std::atomic_load(&slot) používa std::memory_order_seq_cst.

Ak načítanie s poradím acquire prečíta hodnotu zapísanú do toho istého slot volaním std::atomic_store_explicit s std::memory_order_release, zápis sa synchronizuje s načítaním. Inicializácia pred zápisom je potom viditeľná pre kód po načítaní. Samostatná bariéra std::atomic_thread_fence(std::memory_order_release) pred týmto zápisom je pri takomto zverejnení nadbytočná. Načítanie s std::memory_order_relaxed je stále atómové, ale samo osebe túto synchronizáciu nezabezpečuje.

Ak k tomu istému slot pristupuje viac vlákien a aspoň jedno ho môže meniť, nekombinuj toto API s obyčajným kopírovaním, priraďovaním ani volaním reset() na tomto objekte, pokiaľ prístupy nesynchronizuješ samostatne. Napríklad obyčajné priradenie alebo volanie reset() v jednom vlákne môže viesť k dátovým pretekom s atómovým načítaním v inom vlákne. Atómové načítanie nechráni neskoršie zmeny objektu, na ktorý ukazovateľ ukazuje, a nie je zaručené, že prebehne bez zámkov. Tento variant bol zavedený v C++11, označený za zastaraný v C++20, ponechaný v C++23 a odstránený zo štandardu C++26. V novom kóde použi std::atomic<std::shared_ptr<T>> s metódami load(order) a store(value, order).

Príklady

#include <atomic>
#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<const int> slot;
    std::atomic_store_explicit(&slot, std::make_shared<const int>(42),
                               std::memory_order_release);

    const auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);

    std::atomic_store_explicit(&slot, std::shared_ptr<const int>{},
                               std::memory_order_relaxed);
    std::cout << *snapshot << '\n';
}

Výsledok

42

Jednovláknový program vypíše `42`, pretože `snapshot` si zachová podiel na zdieľanom vlastníctve aj po vyprázdnení `slot`. Ukazuje syntax a životnosť, nie synchronizáciu medzi vláknami.

Súvisiace lekcie

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

Zdroje