In my application, I have an int and a bool variable, which are accessed (multiple write/read) by multiple threads. Currently, I am using two mutexes, one for int and one for bool to protect those variables.
I heard about using atomic variables and operators to write lock-free multi-thread program. My questions are
Are these code thread-safe?
double double_m; // double_m is only accessed by current thread.
std::atomic<bool> atomic_bool_x;
atomic_bool_x = true && (double_m > 12.5);
int int_n; // int_n is only accessed by current thread.
std::atomic<int> atomic_int_x;
std::atomic<int> atomic_int_y;
atomic_int_y = atomic_int_x * int_n;
I'm not an expert or anything, but here's what I know:
std::atomic
simply says that calling load
and store
(and a few other operations) concurrently is well-defined. An atomic operation is indivisible - nothing can happen 'in-between'.std::atomic
is based off of boost::atomic
. If you can, use std
, otherwise use boost
.std
being completely so, however your compiler will need to support C++11std::atomic_bool
. You should not need to use volatile.Also, I believe load
/store
differs from operator=
/operator T
only .load
/store
are atomic
Nevermind. I checked the standard and it appears that the operators are defined in terms of load
/store
/etc, however they may return different things.
Further reading: