Devo usare atomico <bool> per la variabile boolea "exit"?

Question

Ho bisogno di impostare un flag per un altro thread per uscire. Quell'altro thread controlla di volta in volta il flag di uscita. Devo usare atomico per la bandiera o solo un semplice bool è sufficiente e perché (con un esempio di cosa esattamente potrebbe andare storto se uso il bool semplice)?

#include <future> 
bool exit = false; 
void thread_fn() 
{ 
    while(!exit) 
    { 
     //do stuff 
     if(exit) break; 
     //do stuff 
    } 
} 
int main() 
{ 
    auto f = std::async(std::launch::async, thread_fn); 
    //do stuff 
    exit = true; 
    f.get(); 
} 

Answer 1

Devo usare atomica per la variabile bool “uscita”?

Sì.

Utilizzare atomic<bool> oppure utilizzare la sincronizzazione manuale tramite (ad esempio) un std::mutex. Il tuo programma contiene attualmente una corsa dati , con una discussione che potenzialmente può leggere una variabile mentre un altro thread la sta scrivendo. Questo è un comportamento indefinito.

al comma 1.10/21 del C++ 11 standard:

L'esecuzione di un programma contiene una gara di dati se contiene due contrastanti azioni in diversi thread, almeno uno dei quali non è atomico e nessuno dei due avviene prima dell'altro. Qualsiasi risultato di tali dati risulta in comportamento non definito.

La definizione di "conflitto" è dato nel paragrafo 1.10/4:

due valutazioni espressione conflitto se uno di loro modifica una locazione di memoria (1.7) e l'altra accede o modifica la stessa posizione di memoria.

Answer 2

Sì, si deve essere sincronizzato con. Il modo più semplice è, come dici tu, con atomic<bool>.

Formalmente, come dice @AndyProwl, la definizione del linguaggio dice che non usare un atomico qui dà un comportamento indefinito. Ci sono buone ragioni per questo.

In primo luogo, una lettura o scrittura di una variabile può essere interrotta a metà tramite un interruttore del filo; l'altro thread può vedere un valore parzialmente scritto, o se modifica il valore, il thread originale vedrà un valore misto. In secondo luogo, quando due thread vengono eseguiti su core diversi, hanno cache separate; scrivendo un valore lo memorizza nella cache, ma non aggiorna altre cache, quindi un thread potrebbe non vedere un valore scritto da un altro thread. Terzo, il compilatore può riorganizzare il codice in base a ciò che vede; nel codice di esempio, se nulla all'interno del ciclo modifica il valore di exit, il compilatore non ha motivo di sospettare che il valore cambierà; può trasformare il ciclo in while(1).

Atomica risolve tutti e tre questi problemi.

Answer 3

in realtà, niente è andato storto con il semplice bool in questo particolare esempio. l'unica nota è dichiarare la variabile di uscita bool come volatile per mantenerla in memoria. entrambe le architetture CISC e RISC implementano la lettura/scrittura bool come istruzione del processore rigorosamente atomico.anche i moderni processori multocore hanno implementato un'implementazione intelligente della cache. quindi, qualsiasi barriera di memoria non è necessaria. la citazione standard non è appropriata per questo caso particolare perché riguarda l'unica scrittura e la lettura dall'unico thread.