{"id":6559,"date":"2023-05-08T10:12:08","date_gmt":"2023-05-08T10:12:08","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/dealing-with-sharing\/"},"modified":"2023-05-08T10:12:08","modified_gmt":"2023-05-08T10:12:08","slug":"dealing-with-sharing","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/dealing-with-sharing\/","title":{"rendered":"Dealing with Sharing"},"content":{"rendered":"

If you don\u2019t share, no data races can happen. Not sharing means that your thread works on local variables. This can be achieved by copying the value, using thread-specific storage, or transferring the result of a thread to its associated future via a protected data channel.<\/p>\n

<\/p>\n

 <\/p>\n

\"Sharing\"<\/p>\n

The patterns in this section are quite obvious, but I will present them with a short explanation for completeness. Let me start with Copied Value.<\/p>\n

Copied Value<\/h2>\n

If a thread gets its arguments by copy and not by reference, there is no need to synchronize access to any data. No data races and no lifetime issues are possible.<\/p>\n

Data Races with References<\/h3>\n

The following program creates three threads. One thread gets its argument by copy, the other by reference, and the last by constant reference.<\/p>\n

<\/p>\n

\n
\/\/ copiedValueDataRace.cpp<\/span>\r\n\r\n#include <functional><\/span>\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <thread><\/span>\r\n\r\nusing<\/span> namespace<\/span> std::<\/span>chrono_literals;\r\n\r\nvoid<\/span> byCopy<\/span>(bool<\/span> b){\r\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>ms);             \/\/ (1)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"byCopy: \"<\/span> <<<\/span> b <<<\/span> '\\n'<\/span>;\r\n}\r\n\r\nvoid<\/span> byReference<\/span>(bool<\/span>&<\/span> b){\r\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>ms);            \/\/ (2)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"byReference: \"<\/span> <<<\/span> b <<<\/span> '\\n'<\/span>;\r\n}\r\n\r\nvoid<\/span> byConstReference<\/span>(const<\/span> bool<\/span>&<\/span> b){\r\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>ms);            \/\/ (3)<\/span><\/em>\r\n    std::<\/span>cout <<<\/span> \"byConstReference: \"<\/span> <<<\/span> b <<<\/span> '\\n'<\/span>;\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha <<<\/span> '\\n'<\/span>;\r\n\r\n    bool<\/span> shared{false<\/span>};\r\n    \r\n    std::<\/span>thread<\/span> t1(byCopy, shared);\r\n    std::<\/span>thread<\/span> t2(byReference, std::<\/span>ref(shared));\r\n    std::<\/span>thread<\/span> t3(byConstReference, std::<\/span>cref(shared));\r\n    \r\n    shared =<\/span> true<\/span>;\r\n    \r\n    t1.join();\r\n    t2.join();\r\n    t3.join();\r\n\r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Each thread sleeps for one millisecond (lines 1, 2, and 3) before displaying the boolean value. Only the thread t1<\/code> has a local copy of the boolean and has, therefore, no data race. The program\u2019s output shows that the boolean values of threads t2<\/code> and t3<\/code> are modified without synchronization.<\/p>\n
\"copiedValueDataRace\"<\/p>\n
You may think that the thread t3 in the previous example copiedValueDataRace.cpp<\/code> can just be replaced with std::thread t3(byConstReference, shared<\/code>). The program compiles and runs, but what seems like a reference is a copy. The reason is that the type traits function std::decay<\/a> is applied to each thread argument. std::decay<\/code> performs lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to its type T<\/code>. In particular, it invokes, in this case, the type traits function std::remove_reference<\/code><\/a> on the type T<\/code>.<\/p>\n
The following program perConstReference.cpp<\/code> uses a non-copyable type NonCopyableClass<\/code>.<\/p>\n
<\/p>\n
\n
\/\/ perConstReference.cpp<\/span>\r\n\r\n#include <thread><\/span>\r\n\r\nclass<\/span> NonCopyableClass<\/span>{\r\n    public:<\/span>\r\n\r\n    \/\/ the compiler generated default constructor<\/span>\r\n    NonCopyableClass() =<\/span> default<\/span>;\r\n\r\n    \/\/ disallow copying<\/span>\r\n    NonCopyableClass&<\/span> operator<\/span> =<\/span> (const<\/span> NonCopyableClass&<\/span>) =<\/span> delete<\/span>;\r\n    NonCopyableClass (const<\/span> NonCopyableClass&<\/span>) =<\/span> delete<\/span>;\r\n  \r\n};\r\n\r\nvoid<\/span> perConstReference<\/span>(const<\/span> NonCopyableClass&<\/span> nonCopy){}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n    NonCopyableClass nonCopy;                      \/\/ (1)<\/span><\/em>\r\n\r\n    perConstReference(nonCopy);                    \/\/ (2)<\/span><\/em>\r\n    \r\n    std::<\/span>thread<\/span> t(perConstReference, nonCopy);     \/\/ (3)<\/span><\/em>\r\n    t.join();\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The object nonCopy<\/code> (line 1) is not copyable. This is fine if I invoke the function perConstReference<\/code> with the argument nonCopy<\/code> (line 2) because the function accepts its argument per constant reference. Using the same function in the thread t<\/code> (line 3) causes GCC to generate a verbose compiler error with more than 300 lines:<\/p>\n
\"numberOfLinesPerConstReference\"<\/p>\n
The error message\u2019s essential part is in the middle of the screenshot in red rounded rectangle: \u201cerror: use of deleted function<\/code>\u201d. The copy-constructor of the class NonCopyableClass<\/code> is not available.<\/p>\n
\"perConstReference\"<\/p>\n
When you borrow something, you have to ensure that the underlying value is still available when you use it.<\/p>\n<\/p>\n
Lifetime Issues with References<\/h3>\n
If a thread uses its argument by reference and you detach the thread, you have to be extremely careful. The small program copiedValueLifetimeIssues.cpp<\/code> has undefined behavior.<\/p>\n
<\/p>\n
\n
\/\/ copiedValueLifetimeIssues.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <string><\/span>\r\n#include <thread><\/span>\r\n\r\nvoid<\/span> executeTwoThreads<\/span>(){                                   \/\/ (1)<\/span><\/em>\r\n    \r\n    const<\/span> std::<\/span>string localString(\"local string\"<\/span>);          \/\/ (4)<\/span><\/em>\r\n    \r\n    std::<\/span>thread<\/span> t1([localString]{\r\n        std::<\/span>cout <<<\/span> \"Per Copy: \"<\/span> <<<\/span> localString <<<\/span> '\\n'<\/span>;\r\n    });\r\n    \r\n     std::<\/span>thread<\/span> t2([&<\/span>localString]{\r\n        std::<\/span>cout <<<\/span> \"Per Reference: \"<\/span> <<<\/span> localString <<<\/span> '\\n'<\/span>;\r\n    });\r\n    \r\n    t1.detach();                                           \/\/ (2)<\/span><\/em>\r\n    t2.detach();                                           \/\/ (3)<\/span><\/em>\r\n}\r\n    \r\nusing<\/span> namespace<\/span> std::<\/span>chrono_literals;\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n    executeTwoThreads();\r\n    \r\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>s);\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
executeTwoThreads<\/code> (lines 1) starts two threads. Both threads are detached (lines 2 and 3) and print the local variable localString<\/code> (line 4). The first thread captures the local variable by copy, and the second the local variable by reference. For simplicity reasons, I used a lambda expression in both cases to bind the arguments. Because the executeTwoThreads<\/code> function doesn\u2019t wait until the two threads have finished, the thread t2<\/code> refers to the local string, which is bound to the lifetime of the invoking function. This causes undefined behavior. Curiously, with GCC the maximum optimized executable -O3<\/code> seems to work, and the non-optimized executable crashes.<\/p>\n
\"copiedValueLifetimeIssues\"<\/p>\n
Thanks to thread-local storage, a thread can easily work on its data.<\/p>\n
Thread-Specific Storage<\/h2>\n
Thread-specific or thread-local storage allows multiple threads to use local storage via a global access point. By using the storage specifier thread_local<\/code>, a variable becomes a thread-local variable. This means you can use the thread-local variable without synchronization.
Assume you want to calculate the sum of all elements of a vector randValues. Doing it with a range-based for-loop is straightforward.<\/p>\n
<\/p>\n
\n
unsigned<\/span> long<\/span> long<\/span> sum{};\r\nfor<\/span> (auto<\/span> n:<\/span> randValues) sum +=<\/span> n;\r\n<\/pre>\n<\/div>\n
 <\/p>\n
But your PC has four cores. Therefore, you make a concurrent program out of the sequential program:<\/p>\n
<\/p>\n
\n
\/\/ threadLocallSummation.cpp<\/span>\r\n\r\n#include <atomic><\/span>\r\n#include <iostream><\/span>\r\n#include <random><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n#include <vector><\/span>\r\n\r\nconstexpr long<\/span> long<\/span> size =<\/span> 10000000<\/span>;   \r\n\r\nconstexpr long<\/span> long<\/span> fir =<\/span>  2500000<\/span>;\r\nconstexpr long<\/span> long<\/span> sec =<\/span>  5000000<\/span>;\r\nconstexpr long<\/span> long<\/span> thi =<\/span>  7500000<\/span>;\r\nconstexpr long<\/span> long<\/span> fou =<\/span> 10000000<\/span>;\r\n\r\nthread_local unsigned<\/span> long<\/span> long<\/span> tmpSum =<\/span> 0<\/span>;\r\n\r\nvoid<\/span> sumUp<\/span>(std::<\/span>atomic<<\/span>unsigned<\/span> long<\/span> long<\/span>>&<\/span> sum, const<\/span> std::<\/span>vector<<\/span>int<\/span>>&<\/span> val, \r\n           unsigned<\/span> long<\/span> long<\/span> beg, unsigned<\/span> long<\/span> long<\/span> end) {\r\n    for<\/span> (auto<\/span> i =<\/span> beg; i <<\/span> end; ++<\/span>i){\r\n        tmpSum +=<\/span> val[i];\r\n    }\r\n    sum.fetch_add(tmpSum);\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>vector<<\/span>int<\/span>><\/span> randValues;\r\n  randValues.reserve(size);\r\n\r\n  std::<\/span>mt19937 engine;\r\n  std::<\/span>uniform_int_distribution<><\/span> uniformDist(1<\/span>, 10<\/span>);\r\n  for<\/span> (long<\/span> long<\/span> i =<\/span> 0<\/span>; i <<\/span> size; ++<\/span>i) \r\n      randValues.push_back(uniformDist(engine));\r\n \r\n  std::<\/span>atomic<<\/span>unsigned<\/span> long<\/span> long<\/span>><\/span> sum{}; \r\n  \r\n  std::<\/span>thread<\/span> t1(sumUp, std::<\/span>ref(sum), std::<\/span>ref(randValues), 0<\/span>, fir);\r\n  std::<\/span>thread<\/span> t2(sumUp, std::<\/span>ref(sum), std::<\/span>ref(randValues), fir, sec);\r\n  std::<\/span>thread<\/span> t3(sumUp, std::<\/span>ref(sum), std::<\/span>ref(randValues), sec, thi);\r\n  std::<\/span>thread<\/span> t4(sumUp, std::<\/span>ref(sum), std::<\/span>ref(randValues), thi, fou);   \r\n  \r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n\r\n  std::<\/span>cout <<<\/span> \"Result: \"<\/span> <<<\/span> sum <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
You put the range-based for-loop into a function and let each thread calculate a fourth of the sum in the thread_local<\/code> variable tmpSum<\/code>. The line sum.fetch_add(tmpSum)<\/code> (line 1) finally sums up all values in the atomic sum<\/code>. You can read more about thread_local storage in my previous post “Thread-Local Data<\/a>“.<\/p>\n
Promises and futures share a protected data channel.<\/p>\n
Future<\/h2>\n
C++11 provides futures and promise in three flavors: std::async<\/code>, std::packaged_tas<\/code>k, and the pair std::promise<\/code> and std::future<\/code>. The future is a read-only placeholder for the value that a promise sets. From the synchronization perspective, a promise\/future pair\u2019s critical property is that a protected data channel connects both. There are a few decisions to make when implementing a future.<\/p>\n