When do I really need to use atomic instead of bool? [duplicate]

by

No type in C++ is “atomic by nature” unless it is an std::atomic*-something. That’s because the standard says so.

In practice, the actual hardware instructions that are emitted to manipulate an std::atomic<bool> may (or may not) be the same as those for an ordinary bool, but being atomic is a larger concept with wider ramifications (e.g. restrictions on compiler re-ordering). Furthermore, some operations (like negation) are overloaded on the atomic operation to create a distinctly different instruction on the hardware than the native, non-atomic read-modify-write sequence of a non-atomic variable.

More Related Contents:

  1. Where is the lock for a std::atomic?
  2. Do I have to use atomic for “exit” bool variable?
  3. Will two atomic writes to different locations in different threads always be seen in the same order by other threads?
  4. Why don’t compilers merge redundant std::atomic writes?
  5. What exactly is std::atomic?
  6. How to implement multithread safe singleton in C++11 without using
  7. Implementing 64 bit atomic counter with 32 bit atomics
  8. Mixing C++11 atomics and OpenMP
  9. How to declare a vector of atomic in C++
  10. What do each memory_order mean?
  11. Is there any compiler barrier which is equal to asm(“” ::: “memory”) in C++11?
  12. How to atomically update a maximum value?
  13. For purposes of ordering, is atomic read-modify-write one operation or two?
  14. Why is the volatile qualifier used through out std::atomic?
  15. Why are std::atomic objects not copyable?
  16. C++11: the difference between memory_order_relaxed and memory_order_consume
  17. How do memory_order_seq_cst and memory_order_acq_rel differ?
  18. c++, std::atomic, what is std::memory_order and how to use them?
  19. Understanding std::atomic::compare_exchange_weak() in C++11
  20. Double-Checked Lock Singleton in C++11
  21. C++11 memory_order_acquire and memory_order_release semantics?
  22. [[carries_dependency]] what it means and how to implement
  23. Acquire/Release versus Sequentially Consistent memory order
  24. std::function vs template
  25. Why is the destructor of a future returned from `std::async` blocking?
  26. When is a private constructor not a private constructor?
  27. Reading from ifstream won’t read whitespace
  28. When is overloading pass by reference (l-value and r-value) preferred to pass-by-value?
  29. Is it wise to ignore gcc/clang’s “-Wmissing-braces” warning?
  30. Is a memory barrier required to read a value that is atomically modified?

Leave a Comment