Home/ Questions/Q 7602061
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-30T23:19:01+00:00

In my application, I have an int and a bool variable, which are accessed

  • 0

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

  1. What’s the definition of atomic variables and operators?
  2. What’s the main difference between std::atomic and
    boost/atomic.hpp? Which one is more standard or popular?
  3. Are these libraries platform-dependent? I am using gnu gcc 4.6 on
    Linux at the moment, but ideally it shall be cross-platform. I heard that the definition of “atomic” actually depends on the hardware as well. Can anyone explain that as well?
  4. What’s the best way to share a bool variable among multiple threads? I would prefer not to use the “volatile” keyword.

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;
Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    I’m not an expert or anything, but here’s what I know:

    1. 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’.
    2. I assume std::atomic is based off of boost::atomic. If you can, use std, otherwise use boost.
    3. They are both portable, with the std being completely so, however your compiler will need to support C++11
    4. Likely std::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:

    • 0