База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

Атомарен запис на std::shared_ptr с изрично зададена паметова подредба

Старото претоварване публикува std::shared_ptr със запис release, съчетан с четене acquire. То все още е част от C++23; в нов код предпочитай std::atomic<std::shared_ptr<T>>.

Версия: ISO C++23; implementation support may vary

Синтаксис

#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) означава претоварването на свободната функция от <memory>, което приема адреса на обикновен std::shared_ptr<T>, а не на std::atomic<T>. То заменя атомарно *p с подадения по стойност параметър desired, все едно изпълнява p->swap(desired), и връща void. p трябва да сочи към жив обект, но записваният shared_ptr може да е празен. Не е гарантирано, че операцията е без заключване.

При едновременна употреба не смесвай тези функции с пряко четене, присвояване или извикване на reset() върху същия споделен екземпляр. std::atomic_load_explicit връща отделен shared_ptr по стойност. Копията могат да споделят контролен блок и да поддържат управлявания обект жив, но не предотвратяват състезания за данни в променливото му съдържание.

Когато четене с std::memory_order_acquire прочете стойността, записана със std::memory_order_release, записът се синхронизира с четенето. Инициализацията преди записа става видима за кода след четенето. std::atomic_thread_fence(std::memory_order_release) непосредствено преди този запис е излишна в тази схема. std::memory_order_relaxed запазва атомарността, но сам по себе си не дава тази гаранция за публикуване. В C++23 старото претоварване за запис изрично забранява acquire и acq_rel, а това за четене забранява release и acq_rel; нарушаването на тези предусловия води до неопределено поведение.

Тези претоварвания на свободни функции са въведени в C++11, обявени са за остарели в C++20 и са премахнати в C++26. Все още са част от C++23; поддръжката зависи от реализацията. В нов код използвай std::atomic<std::shared_ptr<T>> и член-функциите му store и load.

Примери

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

Резултат

42

Главната нишка повтаря четенето acquire, докато получи непразно копие. Тя извежда `42` преди `join()`; конфигурацията се публикува чрез двойката release/acquire, а не чрез `join()`.

Свързани уроци

  • C++ · Урок 37 · Напреднало · Версия: 3

Източници