Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Escrita atómica de std::shared_ptr com ordem de memória explícita

A sobrecarga antiga publica um std::shared_ptr com uma escrita release e uma leitura acquire. Ainda faz parte de C++23; em código novo, prefira std::atomic<std::shared_ptr<T>>.

Versão: ISO C++23; implementation support may vary

Sintaxe

#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) designa a sobrecarga da função não membro de <memory> que recebe o endereço de um std::shared_ptr<T> normal, não o de um std::atomic<T>. Substitui atomicamente *p pelo parâmetro desired passado por valor, como se executasse p->swap(desired), e devolve void. p tem de apontar para um objeto ainda válido, mas o shared_ptr a guardar pode estar vazio. A operação não é necessariamente livre de bloqueios.

Durante a utilização concorrente, não misture estas funções com leituras diretas, atribuições ou chamadas a reset() sobre a mesma instância partilhada. std::atomic_load_explicit devolve por valor um shared_ptr distinto. As cópias podem partilhar um bloco de controlo e manter o objeto gerido vivo, mas não impedem corridas de dados no seu conteúdo modificável.

Quando uma leitura com std::memory_order_acquire lê o valor escrito por uma escrita com std::memory_order_release, a escrita sincroniza-se com a leitura. A inicialização anterior à escrita fica visível para o código após a leitura. Um std::atomic_thread_fence(std::memory_order_release) imediatamente antes dessa escrita é redundante neste padrão. std::memory_order_relaxed preserva a atomicidade, mas não oferece, por si só, esta garantia de publicação. Em C++23, a escrita antiga proíbe explicitamente acquire e acq_rel, e a leitura antiga proíbe release e acq_rel; violar estas pré-condições produz comportamento indefinido.

Estas sobrecargas não membro foram introduzidas em C++11, desaconselhadas em C++20 e removidas em C++26. Ainda fazem parte de C++23; o suporte pode variar consoante a implementação. Em código novo, use std::atomic<std::shared_ptr<T>> e as suas funções membro store e load.

Exemplos

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

Resultado

42

A thread principal repete a leitura acquire até obter uma cópia não vazia. Escreve `42` antes de `join()`; é o par release/acquire que publica a configuração, não `join()`.

Lições relacionadas

  • C++ · Lição 37 · Avançado · Versão: 3

Fontes