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

CKTIS / C++

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

Em C++23, esta sobrecarga descontinuada copia atomicamente um `std::shared_ptr` e permite escolher a ordem de memória da leitura.

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

Sintaxe

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

Esta sobrecarga da função livre std::atomic_load_explicit é declarada em <memory>. Passa &slot, o endereço de um objeto std::shared_ptr<T> cujo tempo de vida ainda não terminou, e não o endereço do objeto apontado nem o de um std::atomic<T>. A função devolve por valor uma cópia de tipo std::shared_ptr<T> e não lança exceções. Se o valor lido participava na propriedade partilhada, a cópia conserva essa participação. Passar um endereço nulo para slot resulta em comportamento indefinido. Já o ponteiro guardado em slot pode ser nulo; se isso for possível, verifica o resultado antes de o desreferenciares.

Em C++23, as ordens de leitura válidas são std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire e std::memory_order_seq_cst. Usar std::memory_order_release ou std::memory_order_acq_rel resulta em comportamento indefinido. A forma abreviada std::atomic_load(&slot) usa std::memory_order_seq_cst.

Se uma leitura com semântica de aquisição ler o valor escrito no mesmo slot por std::atomic_store_explicit com std::memory_order_release, a escrita sincroniza-se com a leitura. A inicialização anterior à escrita fica assim visível ao código executado após a leitura. Uma barreira separada std::atomic_thread_fence(std::memory_order_release) antes dessa escrita é redundante para esta publicação. Uma leitura com std::memory_order_relaxed continua a ser atómica, mas não fornece, por si só, esta sincronização.

Se várias threads acederem ao mesmo slot e pelo menos uma o puder modificar, não mistures esta API com cópias normais, atribuições ou chamadas a reset() nesse objeto, a menos que os acessos sejam sincronizados separadamente. Por exemplo, uma atribuição normal ou uma chamada a reset() numa thread pode causar uma corrida de dados com uma leitura atómica noutra thread. A leitura atómica não protege alterações posteriores ao objeto apontado e não há garantia de que dispense bloqueios. A sobrecarga foi introduzida em C++11, marcada como descontinuada em C++20, mantida em C++23 e removida da norma C++26. Em código novo, usa std::atomic<std::shared_ptr<T>> com load(order) e store(value, order).

Exemplos

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

Resultado

42

O programa com uma única thread escreve `42` porque `snapshot` conserva a propriedade partilhada depois de `slot` ser esvaziado. Demonstra a sintaxe e o tempo de vida, não a sincronização entre threads.

Lições relacionadas

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

Fontes