Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Atomowy zapis std::shared_ptr z jawnym porządkiem pamięci

Starsze przeciążenie pozwala opublikować std::shared_ptr zapisem release i odebrać go odczytem acquire. W C++23 nadal istnieje, ale do nowego kodu wybieraj std::atomic<std::shared_ptr<T>>.

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

Składnia

#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) oznacza wolną funkcję z <memory>, która przyjmuje adres zwykłego std::shared_ptr<T>, a nie adres std::atomic<T>. Atomowo zastępuje *p przekazaną przez wartość kopią wskaźnika desired lub wartością przeniesioną do tego parametru, tak jak przez p->swap(desired), i zwraca void. p musi wskazywać na istniejący obiekt, lecz zapisywany shared_ptr może być pusty. Nie zakładaj, że operacja nie używa blokad.

Nie mieszaj dostępu przez te funkcje z bezpośrednim odczytem, przypisaniem ani reset() tego samego współdzielonego egzemplarza podczas współbieżnego użycia. std::atomic_load_explicit zwraca osobny shared_ptr przez wartość. Takie kopie mogą korzystać z tego samego bloku kontrolnego i podtrzymują czas życia zarządzanego obiektu, ale nie chronią przed wyścigami danych przy modyfikowaniu jego zawartości.

Jeśli odczyt z std::memory_order_acquire pobierze wartość zapisaną z std::memory_order_release, zapis synchronizuje się z odczytem. Inicjalizacja poprzedzająca zapis staje się widoczna dla kodu po odczycie. std::atomic_thread_fence(std::memory_order_release) tuż przed tym zapisem jest w tym schemacie zbędna. std::memory_order_relaxed zachowuje atomowość, ale sama nie zapewnia takiej publikacji. W C++23 starsze przeciążenie zapisu wyklucza acquire i acq_rel, a przeciążenie odczytu wyklucza release i acq_rel; naruszenie tych warunków daje niezdefiniowane zachowanie.

Te wolne przeciążenia wprowadzono w C++11, uznano za przestarzałe w C++20 i usunięto w C++26. W C++23 nadal są częścią standardu; obsługa przez implementacje może się różnić. W nowym kodzie używaj std::atomic<std::shared_ptr<T>> oraz jego metod store i load.

Przykłady

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

Wynik

42

Główny wątek ponawia odczyt acquire, dopóki nie otrzyma niepustej kopii. Wypisuje `42` przed `join()`; publikację zapewnia para release/acquire, nie `join()`.

Powiązane lekcje

  • C++ · Lekcja 37 · Zaawansowany · Wersja: 3

Źródła