Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Scrittura atomica di std::shared_ptr con ordine di memoria esplicito

Il vecchio overload pubblica uno std::shared_ptr con una scrittura release abbinata a una lettura acquire. È ancora presente in C++23; nel nuovo codice preferisci std::atomic<std::shared_ptr<T>>.

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

Sintassi

#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) indica l’overload della funzione non membro in <memory> che riceve l’indirizzo di un normale std::shared_ptr<T>, non quello di uno std::atomic<T>. Sostituisce atomicamente *p con il parametro desired passato per valore, come se eseguisse p->swap(desired), e restituisce void. p deve puntare a un oggetto ancora in vita, ma lo shared_ptr da memorizzare può essere vuoto. Non è garantito che l’operazione sia priva di lock.

Durante l’uso concorrente, non combinare queste funzioni con letture dirette, assegnazioni o chiamate a reset() sulla stessa istanza condivisa. std::atomic_load_explicit restituisce per valore uno shared_ptr distinto. Le copie possono condividere il blocco di controllo e mantenere in vita l’oggetto gestito, ma non impediscono le corse sui dati del suo contenuto modificabile.

Quando una lettura std::memory_order_acquire legge il valore scritto da una scrittura std::memory_order_release, la scrittura si sincronizza con la lettura. L’inizializzazione precedente alla scrittura è quindi visibile al codice dopo la lettura. Una std::atomic_thread_fence(std::memory_order_release) immediatamente prima di quella scrittura è ridondante in questo schema. std::memory_order_relaxed preserva l’atomicità, ma da solo non offre questa garanzia di pubblicazione. In C++23 la vecchia scrittura vieta esplicitamente acquire e acq_rel, mentre la vecchia lettura vieta release e acq_rel; violare queste precondizioni comporta un comportamento indefinito.

Questi overload non membro sono stati introdotti in C++11, deprecati in C++20 e rimossi in C++26. Fanno ancora parte di C++23; il supporto può variare a seconda dell’implementazione. Nel nuovo codice usa std::atomic<std::shared_ptr<T>> e le sue funzioni membro store e load.

Esempi

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

Risultato

42

Il thread principale ripete la lettura acquire finché non ottiene una copia non vuota. Stampa `42` prima di `join()`: è la coppia release/acquire a pubblicare la configurazione, non `join()`.

Lezioni correlate

  • C++ · Lezione 37 · Avanzato · Versione: 3

Fonti