{"id":4750,"date":"2016-05-07T19:27:40","date_gmt":"2016-05-07T19:27:40","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/reader-writer-locks\/"},"modified":"2023-06-26T12:57:50","modified_gmt":"2023-06-26T12:57:50","slug":"reader-writer-locks","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/reader-writer-locks\/","title":{"rendered":"Reader-Writer Locks"},"content":{"rendered":"

With C++14 came reader-writer locks. The idea is straightforward and promising. Arbitrary reading threads can access the critical region simultaneously, but only one thread is allowed to write.<\/p>\n

<\/p>\n

Minimized bottleneck<\/h2>\n

Reader-writer locks do not solve the fundamental problem – threads competing for access to a critical region. But reader-writer locks help a lot – to minimize the bottleneck. Let’s give an example.<\/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\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n61<\/pre>\n<\/td>\n
\n
\/\/ readerWriterLock.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <map><\/span>\r\n#include <shared_mutex><\/span>\r\n#include <string><\/span>\r\n#include <thread><\/span>\r\n\r\nstd::map<std::string,int<\/span>> teleBook{{\"Dijkstra\"<\/span>,1972},{\"Scott\"<\/span>,1976},{\"Ritchie\"<\/span>,1983}};\r\n\r\nstd::shared_timed_mutex teleBookMutex;\r\n\r\nvoid<\/span> addToTeleBook(const<\/span> std::string& na, int<\/span> tele){\r\n  std::lock_guard<std::shared_timed_mutex> writerLock(teleBookMutex);\r\n  std::cout << \"\\nSTARTING UPDATE \"<\/span> << na;\r\n  std::this_thread::sleep_for(std::chrono::milliseconds(500));\r\n  teleBook[na]= tele;\r\n  std::cout << \" ... ENDING UPDATE \"<\/span> << na << std::endl;\r\n}\r\n\r\nvoid<\/span> printNumber(const<\/span> std::string& na){\r\n  std::shared_lock<std::shared_timed_mutex> readerLock(teleBookMutex);\r\n  std::cout << na << \": \"<\/span> << teleBook[na];\r\n}\r\n\r\nint<\/span> main(){\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::thread<\/span> reader1([]{ printNumber(\"Scott\"<\/span>); });\r\n  std::thread<\/span> reader2([]{ printNumber(\"Ritchie\"<\/span>); });\r\n  std::thread<\/span> w1([]{ addToTeleBook(\"Scott\"<\/span>,1968); });\r\n  std::thread<\/span> reader3([]{ printNumber(\"Dijkstra\"<\/span>); });\r\n  std::thread<\/span> reader4([]{ printNumber(\"Scott\"<\/span>); });\r\n  std::thread<\/span> w2([]{ addToTeleBook(\"Bjarne\"<\/span>,1965); });\r\n  std::thread<\/span> reader5([]{ printNumber(\"Scott\"<\/span>); });\r\n  std::thread<\/span> reader6([]{ printNumber(\"Ritchie\"<\/span>); });\r\n  std::thread<\/span> reader7([]{ printNumber(\"Scott\"<\/span>); });\r\n  std::thread<\/span> reader8([]{ printNumber(\"Bjarne\"<\/span>); });\r\n\r\n  reader1.join();\r\n  reader2.join();\r\n  reader3.join();\r\n  reader4.join();\r\n  reader5.join();\r\n  reader6.join();\r\n  reader7.join();\r\n  reader8.join();\r\n  w1.join();\r\n  w2.join();\r\n\r\n  std::cout << std::endl;\r\n\r\n  std::cout << \"\\nThe new telephone book\"<\/span> << std::endl;\r\n  for<\/span> (auto<\/span> teleIt: teleBook){\r\n    std::cout << teleIt.first << \": \"<\/span> << teleIt.second << std::endl;\r\n  }\r\n\r\n  std::cout << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
The telebook<\/span> in line 9 is the shared variable, which has to be protected.<\/span> Eight threads want to read the telephone book; two threads want to modify it (lines 30 – 39). To access the telephone book simultaneously, the reading threads use the std::shared_lock<std::shared_timed_mutex>><\/span> in line 22. This opposes the writing threads, which need exclusive access to the critical section. The exclusivity is given by the std::lock_guard<std::shared_timed_mutex>><\/span> in line 14. In the end, the program displays (lines 54 – 57) the updated telephone book.<\/p>\n
\"readerWriterLocks\"<\/p>\n
The screenshot shows that the output of the reading threads overlaps while the writing thread is executed one after the other. It means that the reading operations are performed at the same time.<\/p>\n
That was easy. Too easy.<\/p>\n<\/p>\n
Undefined behavior<\/h3>\n
The program has undefined behavior. What? Before you continue, stop for a few seconds and think. By the way, the concurrent access of std::cout<\/span> is not the issue.<\/p>\n
The characteristic of a race condition is that at least two threads access the shared variable simultaneously, and at least one of them is a writer. Precisely what is happening in the program. A characteristic of the ordered associative container is that the reading of the container can modify it. It happens if the element is unavailable in the container – the case of “Bjarne”. If “Bjarne” is not found in the telephone book, a pair (“Bjarne”, 0) will be created from the read operation. For the details, have a look at cppreference.com<\/a>.<\/p>\n
What’s next?<\/h2>\n
In the next post<\/a>, I will continue with thread-safe data initialization in multithreading programs.<\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n
 <\/p>\n","protected":false},"excerpt":{"rendered":"
With C++14 came reader-writer locks. The idea is straightforward and promising. Arbitrary reading threads can access the critical region simultaneously, but only one thread is allowed to write.<\/p>\n","protected":false},"author":21,"featured_media":4749,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[366],"tags":[430],"class_list":["post-4750","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading","tag-lock"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4750","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=4750"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4750\/revisions"}],"predecessor-version":[{"id":6982,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/4750\/revisions\/6982"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4749"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=4750"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=4750"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=4750"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}