C ++ 11在递增原子变量并将其赋值给其他值时，它是原子操作吗？

Question

i'm confused about the atomic operation on c++11,

i know the atomic variable self increment is atomic operation,

but i use the assignment to other value, just doubt it.

the code just like:

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

when using the assignment at different threads, is the id unique value?

the test code:

#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;
}

there are three threads,

A class use lock_guard keep unique.

B class just use atomic operation, and assign to the variable

Answer 1

The specification of the atomic increment functions give a crucial insight into their behaviour - from http://en.cppreference.com/w/cpp/atomic/atomic/operator_arith for Integral T types:

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

Notice they return a T by value, and never return the usual T& from a pre-increment. For that reason, the "read" of post-incremented value is not a second distinct operation, and is part of the atomic increment operation itself.

See also the "Return Value" and "Note" text on the above-linked page.

Answer 2

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

when using the assignment at different threads, is the id unique value?

Yes. C++ atomic variables ensure that ++i will be evaluated atomically, so each values of id on different threads are unique.

The expression id = ++i; is executed following steps.

1. atomically increment i , and sub-expression( ++i ) is evaluated post-increment value.
2. assign "evaluated value" to id . (this step is non-atomically)

Answer 3

kaka_ace,

Unfortunately in the case you provided, it isn't atomic.

Here's the reason why the pre-increment operation is atomic, look at the assembly generated:

 add %l0,1,%l0

(might vary a little bit depending on the assembly used)

But that's it. 1 operation. That's why it's atomic.

When you're assigning a pre-increment to a local variable, that's at least two instructions:

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

That generates at least two instructions, and hence is no longer atomic.

Please let me know if you have any questions!