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
- C++23 final working draft (N4950) — shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- WG21 P2869R0 — Remove Deprecated shared_ptr Atomic Access APIs From C++26
- C++ working draft — Annex D compatibility changes from ISO C++ 2023 [diff.cpp23.depr]
- C++ working draft — Order and consistency [atomics.order]
- C++ working draft — Fences [atomics.fences]
- C++ working draft — Partial specialization for shared_ptr [util.smartptr.atomic.shared]