In this post, I will introduce the correct way to use Some experience below is helpful for concurrency coding challenges. <\/p>\n Use Use In the above codes, we use a boolean Java’s Semaphore contains the functionality of both Summary In this post, I will introduce the correct way to use mutex in C++, compared to Java. Conclusion Try not to use std::mutex directly. Use std::unique_lock, std::lock_guard, or std::scoped_lock (since C++17) to manage locking in a more exception-safe manner. Undefined behaviors will happen if a). A mutex is destroyed while still owned by any…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6,33,32,31,5],"tags":[],"class_list":["post-557","post","type-post","status-publish","format-standard","hentry","category-c","category-java","category-muitl-thread","category-parallel-computation","category-proglang"],"_links":{"self":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/557","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/comments?post=557"}],"version-history":[{"count":2,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/557\/revisions"}],"predecessor-version":[{"id":559,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/557\/revisions\/559"}],"wp:attachment":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/media?parent=557"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/categories?post=557"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/tags?post=557"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}mutex<\/code> in C++, compared to Java. <\/p>\nConclusion<\/h2>\n
\n
std::mutex<\/code> directly. <\/li>\nstd::unique_lock<\/code>, std::lock_guard<\/code>, or std::scoped_lock (since C++17)<\/code> to manage locking in a more exception-safe manner.<\/li>\n
\na). A mutex is destroyed while still owned by any threads;
\nb). A thread terminates while owning a mutex;
\nc). std::mutex.lock()<\/code> is called by a thread that already owns the mutex;
\nd). std::mutex.unlock()<\/code> is called but the mutex is not currently locked by the calling thread.<\/li>\nstd::condition_variable<\/code> to control dependency among threads. <\/li>\njava.util.concurrent.Semaphore<\/code> is able to achieve both exclusive blocks and dependency control among threads. <\/li>\n<\/ol>\n\n
std::condition_variable<\/code> to notify them. <\/li>\nstd::mutex<\/code> instances and the same number of std::condition_variable<\/code> instances to transfer computation from a thread to another thread. <\/li>\n<\/ol>\nDetails<\/h2>\n
1. Managment of exclusive blocks<\/h3>\n
std::unique_lock<\/code>. Examples are shown below. <\/p>\n#include <mutex>\n#include <thread>\n#include <iostream>\n#include <vector>\n\nint main() {\n int counter = 0;\n std::mutex counter_mutex;\n std::vector<std::thread> threads;\n\n auto worker_task = [&](int id) {\n \/\/ acquire mutex when unique_lock is created\n std::unique_lock<std::mutex> lock(counter_mutex);\n ++counter;\n std::cout << id << ", initial counter: " << counter << '\\n';\n \/\/ gurantee to release lock after leaving the block, including exceptions, goto, return, etc. \n };\n\n for (int i = 0; i < 10; ++i) threads.emplace_back(worker_task, i);\n\n for (auto &thread : threads) thread.join();\n}<\/code><\/pre>\nstd::unique_lock<\/code> is able to ensure that every time only one thread is running codes in the block. Compared to using std::mutex<\/code> directly, std::unique_lock<\/code> also ensures that the mutex will unlock when leaving the scope where the std::unique_lock<\/code> is defined.<\/p>\n2. Dependency among threads<\/h3>\n
std::condition_variable<\/code> to manage dependency among threads. std::condition_variable<\/code> use wait(unique_lock)<\/code> and notify_all()<\/code> or notify_one()<\/code> heavily. It talks to std::unique_lock<\/code> and often use internal variables (boolean or integer) to help determining the execution order. Examples are shown below. <\/p>\n#include <iostream>\n#include <thread>\n#include <condition_variable>\n#include <mutex>\n#include <chrono>\n#include <queue>\nusing namespace std;\n\ncondition_variable cond_var;\nmutex m;\n\nint main() {\n int value = 100;\n bool notified = false;\n thread reporter([&]() {\n unique_lock<mutex> lock(m);\n while (!notified) {\n cond_var.wait(lock);\n }\n cout << "The value is " << value << endl;\n });\n\n thread assigner([&]() {\n value = 20;\n notified = true;\n cond_var.notify_one();\n });\n\n reporter.join();\n assigner.join();\n return 0;\n}<\/code><\/pre>\nnotified <\/code> to guarantee that the reporter always works after the assigner. Note that we use a while loop in the reporter since generally, the function is notified to wake up by a call in another thread either to member notify_one or to member notify_all, but certain implementations may produce spurious wake-up<\/strong> calls without any of these functions being called. Therefore, we use a while loop to avoid spurious wake-up. <\/p>\n3. Semaphore makes life easier<\/h3>\n
mutex<\/code> and condition_variable<\/code> in C++. See the following coding challenge for example. <\/p>\nimport java.util.concurrent.*;\nclass FooBar {\n private int n;\n Semaphore s1, s2;\n public FooBar(int n) {\n this.n = n;\n s1 = new Semaphore(1);\n s2 = new Semaphore(0);\n }\n\n public void foo(Runnable printFoo) throws InterruptedException {\n\n for (int i = 0; i < n; i++) {\n s1.acquire();\n \/\/ printFoo.run() outputs "foo"\n printFoo.run();\n \/\/ release acts like notifying\n s2.release();\n }\n }\n\n public void bar(Runnable printBar) throws InterruptedException {\n for (int i = 0; i < n; i++) {\n s2.acquire();\n \/\/ printBar.run() outputs "bar"\n printBar.run();\n s1.release();\n }\n }\n}<\/code><\/pre>\n","protected":false},"excerpt":{"rendered":"