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
- P2869R0 — Remove Deprecated Atomic Access APIs From C++26 (includes the legacy wording)
- C++23 working draft N4950 — Deprecated shared_ptr atomic access [depr.util.smartptr.shared.atomic]
- 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]