Uso di base di condizionali con std :: atomico <T>

Question

Quindi sto iniziando a familiarizzare con i tipi di C++ 11 <atomic>. In passato, quando avevo una bandiera atomica, di solito chiudevo semplicemente un mutex prima di accedervi. Un'esigenza comune sarebbe quella di verificare se il flag è false e, in caso affermativo, impostarlo atomicamente su true e quindi fare qualcosa. Quindi, in pratica questo sarebbe compiuto come questo, dove flag è un semplice bool:

{ 
    std::lock_guard<std::mutex> lock(my_mutex); 
    if (!flag) 
    { 
     flag = true; 
     // do something; 
    } 
} 

Così, ora sto cercando di capire come la stessa cosa può essere realizzato con <atomic>. Il docs dice che l'operatore di assegnazione e operator T di un tipo atomico sono operazioni atomiche. Tuttavia, se cambio flag a std::atomic<bool>, immagino non posso semplice esempio:

if (!flag) 
{ 
    flag = true; 
    // do something 
} 

... perché, anche se l'espressione (!flag) è atomico, e l'assegnazione flag = true è atomico, non c'è nulla per impedire un altro thread dalla modifica del flag tra queste due istruzioni.

Quindi, se ho capito bene qui, l'unico corretto utilizzo - affatto - dei condizionali con i tipi atomici, in cui il risultato del condizionale potrebbe modificare la variabile atomica, è quello di utilizzare l'e il funzionamento Confronta Swap ? Ho ragione?

Così, ho dovuto dire:

bool expected = false; 
if (flag.compare_exchange_weak(expected, true)) 
{ 
    // do something 
} 

Ho ragione nella mia comprensione qui?

Answer 1

Se si dispone di più thread su cui è in esecuzione lo stesso codice che è necessario eseguire tale inversione, è necessario utilizzare compare_exchange_weak() o compare_exchange_strong() per il motivo esatto che si suggerisce (probabilmente preferibile forte).

Tuttavia, non è il caso di dire che questo è il solo uso corretto di condizionali con atomica. Se ho, diciamo, un thread che solo legge mai l'atomica e uno che scrive ad esso, è perfettamente ragionevole usare loro il modo più semplice ... per esempio:

std::atomic<bool> done{false}; 

// thread 1 
while (!done) { 
    .... 
} 

// thread 2 
stop() { done = true; } 

Non c'è alcun motivo per me di fare un done.compare_exchange_strong(expected, true) lì. Questo è eccessivo. È davvero su una base caso per caso.

Answer 2

Sì.

Detto questo, si può preferire compare_exchange_strong per questo, a meno che non si sia in un ciclo stretto. Può portare a prestazioni ridotte, ma è garantito per darti il ​​risultato che ti aspetti (che non è lo compare_exchange_weak).

Answer 3

Nota ovvia: la semantica del blocco è molto diversa dalla semplice verifica atomica poiché in questo caso l'altro thread attende fino a quando il blocco non viene rilasciato e eseguirà sempre le azioni dopo l'acquisizione del blocco. Quindi, in senso stretto due esempi di codice non sono equivalenti.