{"id":6278,"date":"2022-01-08T11:50:06","date_gmt":"2022-01-08T11:50:06","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/dining-philiosophers-problem-ii\/"},"modified":"2023-06-26T09:17:44","modified_gmt":"2023-06-26T09:17:44","slug":"dining-philiosophers-problem-ii","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/dining-philiosophers-problem-ii\/","title":{"rendered":"Dining Philosophers Problem II"},"content":{"rendered":"

In the last post “Dining Philosophers Problem I<\/a>“, Andre Adrian<\/strong> started his analysis of the classical dining philosophers’ problem. Today, he uses atomics, mutexes, and locks.<\/p>\n

<\/p>\n

 \"An<\/p>\n

 <\/p>\n

By Benjamin D. Esham \/ Wikimedia Commons, CC BY-SA 3.0, https:\/\/commons.wikimedia.org\/w\/index.php?curid=56559<\/a><\/p>\n

Let me give you a quick reminder about where Andre’s analysis ended last time.<\/p>\n

Still Erroneous Busy Waiting with Resource Hierarchy<\/h2>\n
 <\/div>\n

<\/p>\n

\n
\/\/ dp_5.cpp<\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <chrono><\/span>\r\n#include <atomic><\/span>\r\n\r\nint<\/span> myrand<\/span>(int<\/span> min, int<\/span> max) {\r\n  return<\/span> rand()%<\/span>(max-<\/span>min)+<\/span>min;\r\n}\r\n\r\nvoid<\/span> lock<\/span>(std::<\/span>atomic<<\/span>int<\/span>>&<\/span> m) {\r\n  while<\/span> (m)\r\n    ; \/\/ busy waiting<\/span>\r\n  m=<\/span>1<\/span>;\r\n}\r\n\r\nvoid<\/span> unlock<\/span>(std::<\/span>atomic<<\/span>int<\/span>>&<\/span> m) {\r\n  m=<\/span>0<\/span>;\r\n}\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>atomic<<\/span>int<\/span>>&<\/span> ma, std::<\/span>atomic<<\/span>int<\/span>>&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    lock(ma);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    lock(mb);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    unlock(mb);\r\n    unlock(ma);\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n  std::<\/span>cout<<<\/span>\"dp_5<\/span>\\n<\/span>\"<\/span>;\r\n  srand(time(nullptr));\r\n\r\n  std::<\/span>atomic<<\/span>int<\/span>><\/span> m1{0<\/span>}, m2{0<\/span>}, m3{0<\/span>}, m4{0<\/span>};\r\n\r\n  std::<\/span>thread<\/span> t1([&<\/span>] {phil(1<\/span>, m1, m2);});\r\n  std::<\/span>thread<\/span> t2([&<\/span>] {phil(2<\/span>, m2, m3);});\r\n  std::<\/span>thread<\/span> t3([&<\/span>] {phil(3<\/span>, m3, m4);});\r\n  std::<\/span>thread<\/span> t4([&<\/span>] {phil(4<\/span>, m1, m4);});\r\n\r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The program looks fine but has a tiny chance of misbehavior<\/em>. The two operations “is a resource available” and “mark resource as in use” in the lock()<\/code> function is atomic, but they are still two operations. Between these two operations, the scheduler can place a thread switch. And this thread switches at this most inconvenient time can produce hard-to-find bugs in the program.<\/p>\n<\/p>\n
Optimized Busy Waiting with Resource Hierarchy<\/h2>\n
\n
Thankfully all current computers have an atomic operation “test the resource, and if the test is positive, mark resource as in use”. In the programming language C++, the atomic_flag<\/code> type makes this special “test and set” operation available. The file dp_6.cpp<\/code> is the first correct solution for the dining philosophers problem:<\/p>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_6.cpp<\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <chrono><\/span>\r\n#include <atomic><\/span>\r\n\r\nint<\/span> myrand<\/span>(int<\/span> min, int<\/span> max) {\r\n  return<\/span> rand()%<\/span>(max-<\/span>min)+<\/span>min;\r\n}\r\n\r\nvoid<\/span> lock<\/span>(std::<\/span>atomic_flag&<\/span> m) {\r\n  while<\/span> (m.test_and_set())\r\n    ; \/\/ busy waiting<\/span>\r\n}\r\n\r\nvoid<\/span> unlock<\/span>(std::<\/span>atomic_flag&<\/span> m) {\r\n  m.clear();\r\n}\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>atomic_flag&<\/span> ma, std::<\/span>atomic_flag&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    lock(ma);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    lock(mb);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    unlock(mb);\r\n    unlock(ma);\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n  std::<\/span>cout<<<\/span>\"dp_6<\/span>\\n<\/span>\"<\/span>;\r\n  srand(time(nullptr));\r\n\r\n  std::<\/span>atomic_flag m1, m2, m3, m4;\r\n  unlock(m1);\r\n  unlock(m2);\r\n  unlock(m3);\r\n  unlock(m4);\r\n\r\n  std::<\/span>thread<\/span> t1([&<\/span>] {phil(1<\/span>, m1, m2);});\r\n  std::<\/span>thread<\/span> t2([&<\/span>] {phil(2<\/span>, m2, m3);});\r\n  std::<\/span>thread<\/span> t3([&<\/span>] {phil(3<\/span>, m3, m4);});\r\n  std::<\/span>thread<\/span> t4([&<\/span>] {phil(4<\/span>, m1, m4);});\r\n\r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
The program version 6 output is similar to the last output. The dining philosophers’ problem is good-natured. One resource is only shared between two threads. The atomic_fla<\/code>g spinlock is needed if several threads want to get the same resource.<\/div>\n
 <\/div>\n
\n
Good low CPU load Busy Waiting with Resource Hierarchy<\/h2>\n<\/div>\n
 <\/div>\n
The spinlock disadvantage is the busy waiting. The while loop lock()<\/code> is a waste of CPU resources. A remedy to this problem is putting a function in this while loop’s body. The sleep_for()<\/code> function performs waiting in the scheduler. This waiting is much better than waiting in the application. As always, there is a price. The sleep_for()<\/code> slows down the program’s progress. The file dp_7.cpp<\/code> is the second correct solution:<\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_7.cpp<\/span>
void<\/span> lock<\/span>(std::<\/span>atomic_flag&<\/span> m) {\r\n  while<\/span> (m.test_and_set())\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(8<\/span>));\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
Note: a std::this_thread::yield()<\/code> instead of the sleep_for()<\/code> does not reduce CPU load on the author’s computer. The impact of yield()<\/code> is implementation-dependent.<\/div>\n
\n
std::mutex with Resource Hierarchy<\/h2>\n<\/div>\n
 <\/div>\n
To altogether avoid busy waiting, we need more help from the scheduler. If every thread tells the scheduler the resource state, the scheduler can put a “wait for a resource” thread into the “waiting” state. After the scheduler gets “resource is available” information, the waiting thread state changes to ready. The thread to scheduler information exchange is expensive. Because of this, C++ offers both spinlock and mutex. Spinlock is waiting in the thread, and mutex is waiting in the scheduler.<\/div>\n
File dp_8.cpp<\/code> shows the mutex solution. Please note the #include <mutex><\/code> :<\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_8.cpp<\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <chrono><\/span>\r\n#include <mutex><\/span>\r\n\r\nint<\/span> myrand<\/span>(int<\/span> min, int<\/span> max) {\r\n  return<\/span> rand()%<\/span>(max-<\/span>min)+<\/span>min;\r\n}\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    ma.lock();\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    mb.lock();\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n    mb.unlock(); \/\/ (9)<\/span>\r\n    ma.unlock();\r\n  }\r\n}\r\n\r\nint<\/span> main<\/span>() {\r\n  std::<\/span>cout<<<\/span>\"dp_8<\/span>\\n<\/span>\"<\/span>;\r\n  srand(time(nullptr));\r\n\r\n  std::<\/span>mutex m1, m2, m3, m4;\r\n\r\n  std::<\/span>thread<\/span> t1([&<\/span>] {phil(1<\/span>, m1, m2);});\r\n  std::<\/span>thread<\/span> t2([&<\/span>] {phil(2<\/span>, m2, m3);});\r\n  std::<\/span>thread<\/span> t3([&<\/span>] {phil(3<\/span>, m3, m4);});\r\n  std::<\/span>thread<\/span> t4([&<\/span>] {phil(4<\/span>, m1, m4);});\r\n\r\n  t1.join();\r\n  t2.join();\r\n  t3.join();\r\n  t4.join();\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
Program version 8 is correct and uses very few CPU resources. C++ offers a wrapper to mutex to make life easier for programmers.<\/div>\n
std::lock_guard<\/code> with Resource Hierarchy<\/h2>\n
 <\/div>\n
Using the lock_guard<\/code> template, we put only the mutex into the lock. The mutex member function lock<\/code> is automatically called in the locks constructor and unlock<\/code> its destructor at the end of the scope. unlock<\/code> is also called if an exception is thrown.<\/div>\n
\n
 <\/p>\n
The convenient version is dp_9.cpp<\/code>:<\/p>\n<\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_9.cpp<\/span><\/span>

void<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> ga(ma);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> gb(mb);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n  }\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
We get better and better. Program versions 8 and 9 are correct and are light on the CPU load. But look carefully at the program output:<\/div>\n
 <\/div>\n
 \"dp<\/div>\n<\/div>\n
<\/p>\n
The program output is slightly garbled. Maybe you have seen this output distortion before. Nothing is wrong with the spinlock program versions 6 and 7 or the mutex programs 8 and 9.<\/div>\n
 <\/div>\n
\n
std::lock_guard<\/code> and Synchronized Output with Resource Hierarchy<\/h2>\n<\/div>\n
 <\/div>\n
The console output itself is a resource. That is the reason for garbled output in multi-thread programs. The solution is to put a lock_guard<\/code> around every console output. See dp_10.cpp<\/code>:<\/div>\n
 <\/div>\n
 <\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_10.cpp

std::<\/span>mutex mo;\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> ga(ma);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> gb(mb);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n  }\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
The global mutex mo<\/code> controls the console output resource. Every cout<\/code> statement is in its block, and the lock_guard()<\/code> template ensures that console output is no longer garbled.<\/div>\n
\n
\n
std::lock_guard<\/code> and Synchronized Output with Resource Hierarchy and a count<\/h2>\n<\/div>\n<\/div>\n
 <\/div>\n
\n
\n
As a little bonus, I added dp_11.cpp<\/code>. This program version counts the number of philosophers threads that are eating simultaneously. Because we have 4 forks, there should be times when 2 philosopher threads eat concurrently. Please note that you need again #include <atomic><\/code>. See dp_11.cpp<\/code>:<\/div>\n
 <\/div>\n<\/div>\n<\/div>\n<\/div>\n
<\/p>\n
\n
\/\/ dp_11.cpp

std::<\/span>mutex mo;\r\nstd::<\/span>atomic<<\/span>int<\/span>><\/span> cnt =<\/span> 0<\/span>;\r\n\r\nvoid<\/span> phil<\/span>(int<\/span> ph, std::<\/span>mutex&<\/span> ma, std::<\/span>mutex&<\/span> mb) {\r\n  while<\/span>(true<\/span>) {\r\n    int<\/span> duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>ph<<<\/span>\" thinks \"<\/span><<<\/span>duration<<<\/span>\"ms<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> ga(ma);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got ma<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(1000<\/span>));\r\n\r\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> gb(mb);\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" got mb<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n\r\n    duration=<\/span>myrand(1000<\/span>, 2000<\/span>);\r\n    ++<\/span>cnt;\r\n    {\r\n      std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> g(mo);\r\n      std::<\/span>cout<<<\/span>\"<\/span>\\t\\t\\t\\t<\/span>\"<\/span><<<\/span>ph<<<\/span>\" eats \"<\/span><<<\/span>duration<<<\/span>\"ms \"<\/span><<<\/span>cnt<<<\/span>\"<\/span>\\n<\/span>\"<\/span>;\r\n    }\r\n    std::<\/span>this_thread::<\/span>sleep_for(std::<\/span>chrono::<\/span>milliseconds(duration));\r\n    --<\/span>cnt;\r\n  }\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
\n
The program version 11 output is:<\/div>\n
 <\/div>\n
\"dp<\/div>\n<\/div>\n
 <\/p>\n
The addition is 1 or 2 at the end of the “eats” logging.<\/p>\n
What’s next?<\/h2>\n
In his next installment of the dining philosophers problem, Andre uses std::unique_lock<\/code> (C++11), std::scoped_lock<\/code> (C++17), and std::semaphore<\/code> (C++20).<\/p>\n
 <\/p>\n<\/p>\n
\n
\n
 <\/div>\n
\n
\n
 <\/div>\n
\n
 <\/p>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
In the last post “Dining Philosophers Problem I“, Andre Adrian started his analysis of the classical dining philosophers’ problem. Today, he uses atomics, mutexes, and locks.<\/p>\n","protected":false},"author":21,"featured_media":6268,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[369],"tags":[434,432,430,433],"class_list":["post-6278","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-application","tag-atomics","tag-dining-philosophers","tag-lock","tag-mutex"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6278","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=6278"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6278\/revisions"}],"predecessor-version":[{"id":6686,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6278\/revisions\/6686"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6268"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6278"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6278"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6278"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}