{"id":4795,"date":"2016-06-22T05:44:36","date_gmt":"2016-06-22T05:44:36","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/atomics\/"},"modified":"2023-06-26T12:52:18","modified_gmt":"2023-06-26T12:52:18","slug":"atomics","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/atomics\/","title":{"rendered":"Atomics"},"content":{"rendered":"

In addition to booleans, there is atomics for pointers, integrals, and user-defined types. The rules for user-defined types are special.<\/span><\/p>\n

<\/p>\n

Both. The atomic wrapper on a pointer T* std::atomic<T*> <\/span>or on an integral type integ std::atomic<integ><\/span> enables the CAS (compare-and-swap) operations.<\/p>\n

std::atomic<T*><\/span><\/h2>\n

The atomic pointer std::atomic<T*><\/span> behaves like a plain pointer T*<\/span>. So std::atomic<T*><\/span> supports pointer arithmetic and pre-and post-increment or pre-and post-decrement operations. Have a look at the short example.<\/p>\n

\n
int<\/span> intArray[5];\r\nstd::atomic<int<\/span>*> p(intArray);\r\np++;\r\nassert(p.load() == &intArray[1]);\r\np+=1;\r\nassert(p.load() == &intArray[2]);\r\n--p;\r\nassert(p.load() == &intArray[1]);\r\n<\/pre>\n<\/div>\n
std::atomic<integral type><\/span><\/h2>\n
In C++11, there are atomic types to the known integral data types. As ever, you can read the whole stuff about atomic integral data types – including their operations – on the page en.cppreference.com. <\/a>A std::atomic<integral type><\/span> allows all that a std::atomic_flag<\/span> or a std::atomic<bool><\/span> is capable of, but even more.<\/p>\n
The composite assignment operators +=, -=, &=, |=<\/span> and ^=<\/span> and there pedants std::atomic<>::fetch_add(), std::atomic<>::fetch_sub(), std::atomic<>::fetch_and(), std::atomic<>::fetch_or()<\/span> and std::atomic<>::fetch_xor()<\/span> are the most interesting ones. There is a little difference in the atomic read and write operations. The composite assignment operators return the new value, and the fetch variations the old value. A deeper look gives more insight. There is no multiplication, division, and shift operation in an atomic way. But that is not that big a restriction because these operations are relatively seldom needed and can easily be implemented. How? Look at the example.<\/span><\/p>\n
\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18<\/pre>\n<\/td>\n
\n
\/\/ fetch_mult.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n\r\ntemplate<\/span> <typename<\/span> T>\r\nT fetch_mult(std::atomic<T>& shared, T mult){\r\n  T oldValue= shared.load();\r\n  while<\/span> (!shared.compare_exchange_strong(oldValue, oldValue * mult));\r\n  return<\/span> oldValue;\r\n}\r\n\r\nint<\/span> main(){\r\n  std::atomic<int<\/span>> myInt{5};\r\n  std::cout << myInt << std::endl;          \r\n  fetch_mult(myInt,5);\r\n  std::cout << myInt << std::endl;         \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
I should mention one point. The addition in line 9 will only happen if the relation oldValue == shared<\/span> holds. So to be sure that the multiplication will always take place, I put the multiplication in a while<\/span> loop. The result of the program is not so thrilling.<\/p>\n
\"fetch<\/p>\n
The implementation of the function template fetch_mult<\/span> is generic, too generic. So you can use it with an arbitrary type. In case I use instead of the number 5 the C-String 5, the Microsoft compiler complains that the call is ambiguous.<\/p>\n
\"fetch<\/p>\n
“5” can be interpreted as a const char*<\/span> or an int.<\/span> That was not my intention. <\/span><\/span>The template argument should be an integral type. The correct use case for concepts lite. With concepts lite, you can express constraints to the template parameter. Sad to say, but they will not be part of C++17. We should hope for the C++20 standard.<\/p>\n
\n\n\n\n
\n
1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7<\/pre>\n<\/td>\n
\n
template<\/span> <typename<\/span> T>\r\n  requires std::is_integral<T>::value\r\nT fetch_mult(std::atomic<T>& shared, T mult){\r\n  T oldValue= shared.load();\r\n  while<\/span> (!shared.compare_exchange_strong(oldValue, oldValue * mult));\r\n  return<\/span> oldValue;\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The predicate std::is_integral<T>::value<\/span> will be evaluated by the compiler. If T is not an integral type, the compiler will complain. std::is_integral<\/span> is a function of the new type-traits library<\/a>, part of C++11. The required condition in line 2 defines the constraints on the template parameter. The compiler checks the contract at compile time.<\/p>\n
You can define your atomic types.<\/p>\n<\/p>\n
std::atomic<user defined type><\/h2>\n
There are a lot of severe restrictions on a user-defined type to get an atomic type std::atomic<MyType><\/span>. These restrictions are on the type but on the available operations that std::atomic<MyType><\/span> can perform.<\/p>\n
For MyType, there are the following restrictions:<\/p>\n