![\"thread](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/04\/thread-841607_640.jpg\")
<\/p>\nWriting multithreading programs is hard, even harder if the program should be correct. The rules of the C++ Core Guidelines guide you to writing correct programs. The rules of this post will deal with data races, sharing of data, tasks, and the infamous keyword volatile.<\/p>\n
<\/p>\n
<\/p>\n
Here are the five rules for more details.<\/p>\n
volatile<\/code> for synchronization<\/a><\/li>\n<\/ul>\nLet me directly jump into the first rule.<\/p>\n
CP.2: Avoid data races<\/a><\/h3>\nI already defined the term data race in the last post<\/a>; therefore, I can make it short. A data race is a concurrent writing and reading of data. The effect is undefined behavior. The C++ Core Guidelines provide a typical example of a data race: a static variable.<\/p>\n\nint<\/span> get_id<\/span>() {\r\n static<\/span> int<\/span> id =<\/span> 1<\/span>;\r\n return<\/span> id++<\/span>;\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
What can go wrong? For example, thread A and thread B read the same value, k for id. Afterward, thread A and thread B writes the value k + 1 back. In the end, the id k + 1 exists twice.<\/p>\n
The next example is quite surprising. Here is a small switch block:<\/p>\n
\nunsigned<\/span> val;\r\n\r\nif<\/span> (val <<\/span> 5<\/span>) {\r\n switch<\/span> (val) {\r\n case<\/span> 0<\/span>: \/\/ ...<\/span>\r\n case<\/span> 1<\/span>: \/\/ ...<\/span>\r\n case<\/span> 2<\/span>: \/\/ ...<\/span>\r\n case<\/span> 3<\/span>: \/\/ ...<\/span>\r\n case<\/span> 4<\/span>: \/\/ ...<\/span>\r\n }\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The compiler will often implement the switch block as a jump table. Conceptually, it may look like this.<\/p>\n
<\/p>\n
\nif<\/span> (val <<\/span> 5<\/span>){\r\n \/\/ (1)<\/span>\r\n functions[val]();\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
In this case, functions[3]()<\/span> stands for the functionality of the switch block if val<\/span> is equal to 3. Now it could happen, that another thread kicks in and changes the value at (1) so that it is outside the valid range. Of course, this is undefined behaviour.<\/p>\n<\/p>\nCP.3: Minimize explicit sharing of writable data<\/a><\/h3>\nThis is a straightforward to follow but a significant rule. If your share data, it should be constant. <\/p>\n
Now, you have only to solve the challenge that the shared data is initialized in a thread-safe way. C++11 supports a few ways to achieve this.<\/p>\n
\n- Initialize your data before you start a thread. This is not due to C++11 but often quite easy to apply.\n\n
const<\/span> int<\/span> val =<\/span> 2011<\/span>;\r\nthread<\/span> t1([&<\/span>val]{ .... };\r\nthread<\/span> t2([&<\/span>val]{ .... };\r\n<\/pre>\n<\/div>\n<\/li>\n- Use constant expressions because they are initialized at compile time. \n\n
constexpr auto<\/span> doub =<\/span> 5.1<\/span>;\r\n<\/pre>\n<\/div>\n<\/li>\n- Use the function std::call_once<\/span> in combination with the std::once_flag.<\/span><\/span> You can put the critical initialisation stuff into the function onlyOnceFunc<\/span>. The C++ runtime guarantees that this function runs exactly once successfully.\n\n
std::<\/span>once_flag onceFlag;\r\nvoid<\/span> do_once<\/span>(){\r\n std::<\/span>call_once(onceFlag, [](){ std::<\/span>cout <<<\/span> \"Important initialisation\"<\/span> <<<\/span> std::<\/span>endl; });\r\n}\r\nstd::<\/span>thread<\/span> t1(do_once);\r\nstd::<\/span>thread<\/span> t2(do_once);\r\nstd::<\/span>thread<\/span> t3(do_once);\r\nstd::<\/span>thread<\/span> t4(do_once);\r\n<\/pre>\n<\/div>\n<\/li>\n- Use static variables with block scope because the C++11 runtime guarantees that they are initialized in a thread-safe way. \n\n
void<\/span> func<\/span>(){\r\n ....
static<\/span> int<\/span> val 2011<\/span>;
....\r\n}\r\nthread<\/span> t5{ func() };\r\nthread<\/span> t6{ func() };\r\n<\/pre>\n<\/div>\n<\/li>\n<\/ol>\nCP.4: Think in terms of tasks, rather than threads<\/a><\/h3>\nFirst of all. What is a task? A task is a term in C++11 that stands for two components: a promise and a future. Promise exists in three variations in C++: std::async, std::packaged_task,<\/span> and std::promise. <\/span>I have already written a few posts on tasks<\/a>.<\/p>\nA thread, a std::packaged_task,<\/span> or a std::promise<\/span> have in common that they are quite low-level; therefore, I will write about a std::async<\/span>. <\/p>\nHere are a thread and a future and promise pair to calculate the sum of 3 + 4.<\/p>\n
\n\/\/ thread<\/span>\r\nint<\/span> res;\r\nthread<\/span> t([&<\/span>]{ res =<\/span> 3<\/span> +<\/span> 4<\/span>; });\r\nt.join();\r\ncout <<<\/span> res <<<\/span> endl;\r\n\r\n\/\/ task<\/span>\r\nauto<\/span> fut =<\/span> async([]{ return<\/span> 3<\/span> +<\/span> 4<\/span>; });\r\ncout <<<\/span> fut.get() <<<\/span> endl;\r\n<\/pre>\n<\/div>\n <\/p>\n
What is the fundamental difference between a thread and a future and promise pair? A thread is about how something should be calculated; a task is about what should be calculated.<\/strong><\/p>\nLet me be more specific.<\/p>\n
\n- The thread uses the shared variable res<\/span> to provide its results. In contrast, the promise std::async<\/span> uses a secure data channel to communicate its result to the future fut.T<\/span>his means for the thread in particular that, you have to protect res.<\/span><\/li>\n
- In the case of a thread, you explicitly create a thread. This will not hold for the promise because you just specify what should be calculated.<\/li>\n<\/ul>\n
CP.8: Don\u2019t try to use volatile<\/code> for synchronization<\/a><\/h3>\nIf you want an atomic in Java or C# you declare it as volatile<\/span>. Relatively easy in C++, or? If you want to have an atomic in C++, use volatile<\/span>. Wrong. volatile<\/span> has no multithreading-semantic in C++. Atomics is called std::atomic<\/span> in C++11.<\/p>\nNow, I’m curious: What does volatile mean in C++? volatile<\/span> is for special objects on which optimized read or write operations are not allowed.<\/p>\nvolatile<\/span> is typically used in embedded programming to denote objects, which can change independently of the regular program flow. These are, for example, objects which represent an external device (memory-mapped I\/O). Because these objects can change independently of the regular program, their value will be written directly to the main memory. So there is no optimized storing in caches.<\/p>\nWhat’s next?<\/h2>\n
Correct multithreading is hard. This is why you should use each possible tool to validate your code. With the dynamic code analyzer ThreadSanitizer<\/a> and the static code analyzer CppMem<\/a> two tools should be in the toolbox of each serious multithreading programmer. In the next post<\/a>, you will see why. <\/p>\n <\/p>\n
<\/p>\n
<\/p>\n
<\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
Writing multithreading programs is hard, even harder if the program should be correct. The rules of the C++ Core Guidelines guide you to writing correct programs. The rules of this post will deal with data races, sharing of data, tasks, and the infamous keyword volatile.<\/p>\n","protected":false},"author":21,"featured_media":5429,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[372],"tags":[446,457],"class_list":["post-5430","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-modern-c","tag-tasks","tag-volatile"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5430","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=5430"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5430\/revisions"}],"predecessor-version":[{"id":6829,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5430\/revisions\/6829"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5429"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5430"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5430"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5430"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}