É seguro ler um ponteiro para um atomic sem sincronização, supondo que ele nunca será um nullptr? Como no código a seguir, suponha que há duas threads em execução writere readersimultaneamente.
std::atomic<int>* g_atomic = new std::atomic<int>{};
void writer()
{
for (int i = 0; i < 101; i++)
{
auto* new_atomic = new std::atomic<int>{i};
std::atomic_thread_fence(std::memory_order_seq_cst); // memory barrier.
g_atomic = new_atomic; // ignore the memory leak
}
}
void reader()
{
auto value = g_atomic->load();
while (value < 100)
{
assert(value >= 0 && value <= 100);
value = g_atomic->load();
}
}
por seguro quero dizer que sempre lerei um valor de 0 a 100, não lerei um ponteiro inválido nem lerei o objeto apontado antes de sua inicialização.
minha intuição me diz que isso é seguro porque
- ponteiros são lidos ou escritos atomicamente em todas as arquiteturas.
- o valor apontado é lido atomicamente, ele precisa ser buscado na RAM, e a barreira de memória antes da gravação garante que a RAM esteja sempre correta.
Então, isso é seguro? Talvez apenas em todas as arquiteturas comuns?
