C++ 11 quando incrementa la variabile atomica e la assegna ad un altro valore, è un'operazione atomica?

Question

Sono confuso circa il funzionamento atomica su C++ 11,

So che il atomica sé incremento variabile è un'operazione atomica,

ma io uso il compito di altro valore, solo dubitarne.

il codice, proprio come:

//.... 
static std::atomic<int> i; // global variable 
//.... 
// in the thread 
int id = ++i; 

quando si utilizza l'assegnazione a diversi thread, è il valore unico id?

il codice di prova:

#include <thread> 
#include <mutex> 
#include <atomic> 
#include <iostream> 

class A { 
public: 
    static int idGenerator; 
    static std::mutex m; 
    A() { 
     // i know this operation will keep the id_ is unique 
     std::lock_guard<std::mutex> lock(m); 
     id_ = ++idGenerator; 
    } 
    void F(std::string name) { 
     std::cout << name << " " << id_ << std::endl; 
    } 
private: 
    int id_; 
}; 
int A::idGenerator = 0; 
std::mutex A::m; 

class B { 
public: 
    static int idGenerator; 
    B() { 
     // after self increment, is the assignment atomic? 
     id_ = (++idGenerator); 
    } 
    void F(std::string name) { 
     std::cout << name << " " << id_.load() << std::endl; 
    } 
private: 
    std::atomic<int> id_; 
}; 
int B::idGenerator = 0; 


void funcA() { 
    A a2; 
    a2.F("a2"); 
} 

void funcB() { 
    B b2; 
    b2.F("b2"); 
} 

int main() { 
    A a1; 
    B b1; 
    std::thread t1(&funcA); 
    std::thread t2(&funcB); 
    a1.F("a1"); 
    b1.F("b1"); 

    t1.join(); 
    t2.join(); 
    return 0; 
} 

ci sono tre fili,

Una classe di utilizzo lock_guard mantengono unico.

classe B basta usare operazione atomica, e assegnare alla variabile

Answer 1

kaka_ace,

Purtroppo nel caso che hai fornito, non è atomica.

Ecco il motivo per cui l'operazione di pre-incremento è atomico, guarda l'assembly generato:

add %l0,1,%l0 

(possono variare un po 'a seconda dell'armatura utilizzata)

Ma questo è tutto. 1 operazione. Ecco perché è atomico.

Quando si sta assegnando un pre-incremento a una variabile locale, che è almeno due istruzioni:

add %l0,1,%l0 
st l0, [%fp-4] 

che genera almeno due istruzioni, e quindi non è più atomica.

Per favore fatemi sapere se avete domande!

Answer 2

La specifica delle funzioni di incremento atomiche dare una visione cruciale nel loro comportamento - da http://en.cppreference.com/w/cpp/atomic/atomic/operator_arith per Integral T tipi:

T operator++(); 
T operator++() volatile; 
T operator++(int); 
T operator++(int) volatile; 

Avviso ritornano un T per valore, e non tornare il solito T& da un pre -incremento. Per questo motivo, la "lettura" del valore post-incrementato non è una seconda operazione distinta e fa parte dell'operazione di incremento atomico stessa.

Vedere anche il testo "Valore restituito" e "Nota" nella pagina in alto.

Answer 3

static std::atomic<int> i; // global variable 
// in the thread 
int id = ++i; 

quando utilizza l'assegnazione in diversi thread, è il valore unico id?

Sì. Le variabili atomiche C++ assicurano che il valore ++i venga valutato in modo atomico, pertanto ciascun valore di id su thread diversi è univoco.

L'espressione id = ++i; viene eseguita seguendo i passaggi.

1. atomicamente INCREMENT i, e sub-espressione (++i) viene valutato valore post-incremento.
2. assegnare "valore valutato" a id. (questo passaggio non è atomico)