Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Atomsko učitavanje `std::shared_ptr` s izričitim memorijskim poretkom

U C++23 ovo zastarjelo preopterećenje atomski kopira `std::shared_ptr` i omogućuje odabir memorijskog poretka pri učitavanju.

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

Sintaksa

// 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);

Ovo preopterećenje slobodne funkcije std::atomic_load_explicit deklarirano je u <memory>. Predaj &slot, adresu objekta std::shared_ptr<T> čiji životni vijek još traje, a ne adresu objekta na koji pokazuje niti adresu objekta std::atomic<T>. Funkcija vraća kopiju tipa std::shared_ptr<T> po vrijednosti i ne baca iznimke. Ako je učitana vrijednost sudjelovala u dijeljenom vlasništvu, kopija zadržava taj udio. Predavanje nul-adrese za slot uzrokuje nedefinirano ponašanje. Pokazivač pohranjen u slot smije biti nul-pokazivač; ako je to moguće, provjeri rezultat prije dereferenciranja.

U C++23 dopušteni poreci za učitavanje su std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire i std::memory_order_seq_cst. Uporaba std::memory_order_release ili std::memory_order_acq_rel uzrokuje nedefinirano ponašanje. Kraći zapis std::atomic_load(&slot) koristi std::memory_order_seq_cst.

Ako učitavanje s poretkom acquire pročita vrijednost koju je std::atomic_store_explicit uz std::memory_order_release zapisao u isti slot, zapis se sinkronizira s učitavanjem. Inicijalizacija obavljena prije zapisa tada je vidljiva kodu nakon učitavanja. Zasebna barijera std::atomic_thread_fence(std::memory_order_release) prije tog zapisa suvišna je za ovu objavu. Učitavanje uz std::memory_order_relaxed i dalje je atomsko, ali samo po sebi ne osigurava tu sinkronizaciju.

Ako više dretvi pristupa istom slot i barem ga jedna može mijenjati, nemoj kombinirati ovaj API s običnim kopiranjem, dodjelom ili pozivima reset() na tom objektu, osim ako su pristupi zasebno sinkronizirani. Na primjer, obična dodjela ili poziv reset() u jednoj dretvi može izazvati podatkovnu utrku s atomskim učitavanjem u drugoj dretvi. Atomsko učitavanje ne štiti kasnije izmjene objekta na koji pokazivač pokazuje i nije zajamčeno da radi bez zaključavanja. Preopterećenje je uvedeno u C++11, označeno zastarjelim u C++20, zadržano u C++23 i uklonjeno iz standarda C++26. U novom kodu koristi std::atomic<std::shared_ptr<T>> s metodama load(order) i store(value, order).

Primjeri

#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';
}

Rezultat

42

Program s jednom dretvom ispisuje `42` jer `snapshot` zadržava udio u dijeljenom vlasništvu nakon pražnjenja `slot`. Prikazuje sintaksu i životni vijek, a ne sinkronizaciju među dretvama.

Povezane lekcije

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

Izvori