Eu tenho um código no trabalho que inicia vários threads que realizam algumas operações e, se algum deles falhar, eles definem a variável compartilhada comofalso.

O thread principal une todos os threads de trabalho. A simulação disso é mais ou menos assim (comentei a possível correção que não sei se é necessária):

#include <thread>
#include <atomic>
#include <vector>
#include <iostream>
#include <cassert>

using namespace std;

//atomic_bool success = true;
bool success = true;

int main()
{
    vector<thread> v;
    for (int i = 0; i < 10; ++i)
    {
        v.emplace_back([=]
        {
            if (i == 5 || i == 6)
            {
                //success.store(false, memory_order_release);
                success = false;
            }
        });
    }
    for (auto& t : v)
        t.join();

    //assert(success.load(memory_order_acquire) == false);
    assert(success == false);

    cout << "Finished" << endl;
    cin.get();
    return 0;
}

Existe a possibilidade de que o thread principal leia a variável success comoverdadeiro mesmo que um dos trabalhadores tenha definidofalso?

eu achei aquilothread :: join () é uma barreira de memória cheia (fonte) mas isso implicasincronizado com relacionamento com a seguinte leitura desucesso variável do segmento principal, para garantir o valor mais novo?

A correção que eu publiquei (no código comentado) é necessária neste caso (ou talvez outra correção se esta estiver errada)?

Existe a possibilidade de ler sobresucesso A variável será otimizada (já que não é volátil) e obteremos um valor antigo, independentemente dadeveria existir barreira de memória implícita emthread :: join?

Supõe-se que o código funcione em várias arquiteturas (não me lembro de todas, não tenho makefile na minha frente), mas há pelo menos x86, amd64, itanium, arm7.

Obrigado por qualquer ajuda com isso.

Edit: Eu modifiquei o exemplo, porque na situação real mais de um thread pode tentar gravar emsucesso variável.