Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Chargement atomique d’un `std::shared_ptr` avec ordre mémoire explicite

En C++23, cette surcharge dépréciée copie un `std::shared_ptr` de façon atomique et permet de choisir l’ordre mémoire du chargement.

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

Syntaxe

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

Cette surcharge de la fonction libre std::atomic_load_explicit est déclarée dans <memory>. Passez &slot, l’adresse d’un objet std::shared_ptr<T> dont la durée de vie est en cours, et non l’adresse de l’objet pointé ni celle d’un std::atomic<T>. La fonction renvoie une copie de type std::shared_ptr<T> par valeur, sans lever d’exception. Si la valeur chargée participait à la possession partagée, la copie conserve cette participation. Passer une adresse nulle pour slot entraîne un comportement indéfini. En revanche, le pointeur stocké dans slot peut être nul ; si c’est possible, vérifiez le résultat avant de le déréférencer.

En C++23, les ordres de chargement autorisés sont std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire et std::memory_order_seq_cst. Avec std::memory_order_release ou std::memory_order_acq_rel, le comportement est indéfini. La forme courte std::atomic_load(&slot) utilise std::memory_order_seq_cst.

Si un chargement avec sémantique d’acquisition lit la valeur écrite dans le même slot par std::atomic_store_explicit avec std::memory_order_release, l’écriture se synchronise avec la lecture. L’initialisation effectuée avant l’écriture est alors visible par le code exécuté après la lecture. Une barrière séparée std::atomic_thread_fence(std::memory_order_release) avant cette écriture est redondante pour cette publication. Un chargement avec std::memory_order_relaxed reste atomique, mais ne fournit pas à lui seul cette synchronisation.

Si plusieurs threads accèdent au même slot et qu’au moins l’un d’eux peut le modifier, ne mélangez pas cette API avec une copie ordinaire, une affectation ou un appel à reset() sur cet objet, sauf si les accès sont synchronisés séparément. Par exemple, une affectation ordinaire ou un appel à reset() dans un thread peut provoquer une course de données avec un chargement atomique dans un autre thread. Le chargement atomique ne protège pas les modifications ultérieures de l’objet pointé et n’est pas garanti sans verrou. La surcharge a été introduite en C++11, dépréciée en C++20, conservée en C++23 et retirée de la norme C++26. Pour du nouveau code, utilisez std::atomic<std::shared_ptr<T>> avec load(order) et store(value, order).

Exemples

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

Résultat

42

Le programme à un seul thread affiche `42`, car `snapshot` conserve sa part de possession après le vidage de `slot`. Il illustre la syntaxe et la durée de vie, pas la synchronisation entre threads.

Leçons associées

  • C++ · Leçon 37 · Avancé · Version : 3

Sources