Grundlegende Verwendung von Bedingungen mit std :: atomic <T>

Question

So beginne ich mich mit C++ 11 <atomic> Arten vertraut machen. In der Vergangenheit, als ich eine atomare Flagge hatte, würde ich normalerweise einfach einen Mutex sperren, bevor ich darauf zugreife. Eine allgemeine Notwendigkeit wäre, zu überprüfen, ob das Flag false ist, und wenn ja, setze es atomisch auf true und dann etwas tun. Also im Grunde wäre dies wie dies erreicht werden, wo flag ist ein einfaches bool:

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

So, jetzt ich versuche, herauszufinden, wie das gleiche kann mit <atomic> erreicht werden. Die docs sagen, dass der Zuweisungsoperator und operator T eines atomaren Typs atomare Operationen sind. Allerdings, wenn ich flag zu std::atomic<bool> ändern, ich denke, ich kann nicht einfach sagen:

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

... weil, obwohl der Ausdruck (!flag) atomar ist, und die Zuordnung flag = true ist atomar, gibt es nichts, einen anderen Thread zu verhindern zwischen dem Ändern des Flags zwischen diesen beiden Anweisungen.

Also, wenn ich das richtig hier, die einzige richtige Verwendung verstehen - bei allen - von conditionals mit atomaren Typen, in dem das Ergebnis der bedingten die atomare Variable ändern könnte, ist das verwenden Vergleichs- und Auslagerungsoperation ? Hab ich recht?

Also, ich würde sagen:

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

Bin ich in meinem Verständnis korrigieren hier?

Answer 1

Wenn Sie mehrere Threads, die denselben Code ausführen, dass die Flip tun müssen, ja - Sie müssen compare_exchange_weak() oder compare_exchange_strong() für das genau der Grund, verwenden Sie vorschlagen (wahrscheinlich stark bevorzugen).

Es ist jedoch nicht der Fall zu sagen, dass dies die nur ordnungsgemäße Verwendung von Bedingungen mit Atomics ist. Wenn ich, sagen wir, ein Thread, der immer nur die atomare und man liest, die sie schreibt, ist es durchaus sinnvoll sie die einfache Art und Weise zu verwenden, ... zB:

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

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

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

Es gibt keinen Grund für mich zu tun done.compare_exchange_strong(expected, true) dort. Das ist Overkill. Es ist wirklich von Fall zu Fall.

Answer 2

Ja.

Davon abgesehen, können Sie dafür compare_exchange_strong bevorzugen, es sei denn, Sie sind in einer engen Schleife. Es kann zu einer verminderten Leistung führen, garantiert Ihnen aber das Ergebnis, das Sie erwarten (was nicht compare_exchange_weak ist).

Answer 3

Offensichtlicher Hinweis: Lock-Semantik ist ziemlich anders als nur atomare Prüfung, da in diesem Fall der andere Thread wartet, bis Sperre freigegeben wird und seine Aktionen immer ausführen, nachdem Sperre erworben ist. Genau genommen sind also zwei Codebeispiele nicht gleichwertig.