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

CKTIS / C++

Leituras e escritas atómicas de shared_ptr através de funções livres

As sobrecargas de std::atomic_store_explicit e std::atomic_load_explicit para std::shared_ptr substituem e leem atomicamente o valor de um ponteiro inteligente com propriedade partilhada. Estão obsoletas em C++23; protegem o ponteiro inteligente e a propriedade partilhada, não operações arbitrárias sobre o objeto apontado.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <memory>
#include <atomic>

template<class T>
void atomic_store_explicit(std::shared_ptr<T>* p,
                           std::shared_ptr<T> desired,
                           std::memory_order order);

template<class T>
std::shared_ptr<T> atomic_load_explicit(const std::shared_ptr<T>* p,
                                        std::memory_order order);
// Both function templates belong to namespace std.

Em C++23, estas funções de <memory> operam sobre um objeto normal std::shared_ptr<T>, não sobre um std::atomic<T>. std::atomic_store_explicit(std::shared_ptr<T>*, ...) substitui atomicamente o valor do ponteiro inteligente por desired e devolve void. std::atomic_load_explicit(const std::shared_ptr<T>*, ...) devolve atomicamente uma cópia do std::shared_ptr<T> que mantém a propriedade partilhada. O ponteiro p tem de designar um objeto vivo; uma leitura pode devolver um std::shared_ptr<T> vazio.

O parâmetro order seleciona a ordenação da memória. Para escritas, são permitidos std::memory_order_relaxed, std::memory_order_release e std::memory_order_seq_cst. Em C++23, para leituras, são permitidos std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire e std::memory_order_seq_cst. Outras ordenações causam comportamento indefinido. Uma leitura acquire que lê o valor publicado por uma escrita release torna visível a inicialização anterior; relaxed, por si só, não proporciona essa sincronização.

Não combines estas operações com uma atribuição normal, reset() ou a cópia do mesmo objeto std::shared_ptr<T> quando o acesso puder coincidir com uma escrita: isso pode causar uma condição de corrida nos dados. O acesso atómico ao ponteiro inteligente não protege as alterações a *snapshot; estas exigem sincronização separada. Também não pressuponhas que a operação não usa bloqueios. Mantém o objeto slot vivo durante todos os acessos.

Esta é uma interface antiga, obsoleta desde C++20 e removida em C++26. O endereço atual da secção fornecida apenas informa sobre a remoção; não é uma captura de C++23. A alternativa é std::atomic<std::shared_ptr<T>> com os métodos store() e load(), que expressam o acesso atómico no tipo. Esta entrada diz respeito a C++23; a opção do compilador do repositório não atesta um ambiente de produção.

Exemplos

#include <atomic>
#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<const int> slot;
    std::shared_ptr<const int> value = std::make_shared<const int>(42);

    std::atomic_store_explicit(&slot, value, std::memory_order_release);
    auto snapshot = std::atomic_load_explicit(&slot, std::memory_order_acquire);

    std::cout << *snapshot << '\n';
}

Resultado

42

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes