{"id":7661,"date":"2023-07-01T09:21:14","date_gmt":"2023-07-01T09:21:14","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=7661"},"modified":"2023-08-23T17:02:40","modified_gmt":"2023-08-23T17:02:40","slug":"thread-safe-queue-two-serious-errors","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/thread-safe-queue-two-serious-errors\/","title":{"rendered":"Thread-Safe Queue – Two Serious Errors"},"content":{"rendered":"\n

In my last post “Monitor Object<\/a>”  I implemented a thread-safe queue. I made two serious errors. Sorry. Today, I will fix these issues.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

First, I want to show you again the erroneous implementation from my last post to understand the context.<\/p>\n\n\n\n

\/\/ monitorObject.cpp<\/span>\n\n#include <condition_variable><\/span>\n#include <functional><\/span>\n#include <queue><\/span>\n#include <iostream><\/span>\n#include <mutex><\/span>\n#include <random><\/span>\n#include <thread><\/span>\n\nclass<\/span> Monitor<\/span> {\npublic:<\/span>\n    void<\/span> lock() const<\/span> {\n        monitMutex.lock();\n    }\n\n    void<\/span> unlock() const<\/span> {\n        monitMutex.unlock();\n    }\n\n    void<\/span> notify_one() const<\/span> noexcept {\n        monitCond.notify_one();\n    }\n\n    template<\/span> <<\/span>typename<\/span> Predicate><\/span>\n    void<\/span> wait(Predicate pred) const<\/span> {                 \/\/ (10)<\/span>\n        std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> monitLock(monitMutex);\n        monitCond.wait(monitLock, pred);\n    }\n    \nprivate:<\/span>\n    mutable<\/span> std::<\/span>mutex monitMutex;\n    mutable<\/span> std::<\/span>condition_variable monitCond;\n};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>                                  \/\/ (1)<\/span>\nclass<\/span> ThreadSafeQueue<\/span>:<\/span> public<\/span> Monitor {\n public:<\/span>\n    void<\/span> add(T val){ \n        lock();\n        myQueue.push(val);                             \/\/ (6)<\/span>\n        unlock();\n        notify_one();\n    }\n    \n    T get(){ \n        wait( [this<\/span>] { return<\/span> !<\/span> myQueue.empty(); } );  \/\/ (2)<\/span>\n        lock();\n        auto<\/span> val =<\/span> myQueue.front();                    \/\/ (4)<\/span>\n        myQueue.pop();                                 \/\/ (5)<\/span>\n        unlock();\n        return<\/span> val;\n    }\n\nprivate:<\/span>\n    std::<\/span>queue<<\/span>T><\/span> myQueue;                            \/\/ (3)<\/span>\n};\n\n\nclass<\/span> Dice<\/span> {\npublic:<\/span>\n    int<\/span> operator<\/span>()(){ return<\/span> rand(); }\nprivate:<\/span>\n    std::<\/span>function<<\/span>int<\/span>()><\/span> rand =<\/span> std::<\/span>bind(std::<\/span>uniform_int_distribution<><\/span>(1<\/span>, 6<\/span>), \n                                          std::<\/span>default_random_engine());\n};\n\n\nint<\/span> main<\/span>(){\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    constexpr auto<\/span> NumberThreads =<\/span> 100<\/span>;\n    \n    ThreadSafeQueue<<\/span>int<\/span>><\/span> safeQueue;                      \/\/ (7)<\/span>\n\n    auto<\/span> addLambda =<\/span> [&<\/span>safeQueue](int<\/span> val){ safeQueue.add(val);          \/\/ (8)<\/span>\n                                            std::<\/span>cout <<<\/span> val <<<\/span> " "<\/span>\n                                            <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> "; "<\/span>; \n                                          }; \n    auto<\/span> getLambda =<\/span> [&<\/span>safeQueue]{ safeQueue.get(); };  \/\/ (9)<\/span>\n\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> addThreads(NumberThreads);\n    Dice dice;\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> addThreads) thr =<\/span> std::<\/span>thread<\/span>(addLambda, dice());\n\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> getThreads(NumberThreads);\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> getThreads) thr =<\/span> std::<\/span>thread<\/span>(getLambda);\n\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> addThreads) thr.join();\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> getThreads) thr.join();\n    \n    std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n     \n}\n<\/pre><\/div>\n\n\n\n
The key idea of the example is that the Monitor Object is encapsulated in a class and can, therefore, be reused. The class Monitor<\/code> uses a std::mutex<\/code> as monitor lock and a std::condition_variable<\/code><\/a> as monitor condition. The class Monitor<\/code> provides the minimal interface that a Monitor Object should support.<\/p>\n\n\n\n
ThreadSafeQueue<\/code> in line (1) extends  std::queue<\/code> in line (3) with a thread-safe interface. ThreadSafeQueue<\/code> derives from the class Monitor<\/code> and uses its member functions to support the synchronized member functions add<\/code> and get. The member functions add<\/code> and get<\/code> use the monitor lock to protect the Monitor Object, particularly the non-thread-safe myQueue<\/code>. add<\/code> notifies the waiting thread when a new item was added to myQueue<\/code>. This notification is thread-safe. The member function get<\/code> (line (3)) deserves more attention. First, the wait <\/code>member function of the underlying condition variable is called. This wait<\/code> call needs an additional predicate to protect against spurious and lost wakeups (C++ Core Guidelines: Be Aware of the Traps of Condition Variables<\/a>). The operations modifying  myQueue<\/code> (lines 4 and 5) must also be protected because they can interleave with the call myQueue.push(val)<\/code> (line 6). The Monitor Object safeQueue<\/code> line (7) uses the lambda functions in lines (8) and (9) to add or remove a number from the synchronized safeQueue<\/code>. ThreadSafeQueue<\/code> itself is a class template and can hold values from an arbitrary type. One hundred clients add 100 random numbers between 1 – 6 to  safeQueue<\/code> (line 7), while hundred clients remove these 100 numbers concurrently from the safeQueue<\/code>. The output of the program shows the numbers and the thread ids.<\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
This program has two serious issues. Dietmar K\u00fchl<\/strong> and Frank Birbacher<\/strong> wrote me an e-mail about it. These are their words, which I translated into English. My additions are cursive and bold.<\/em><\/strong><\/div>
\u00a0<\/div>
  1. In ThreadSafeQueue::get()<\/code> it is tested by Monitor::wait()<\/code> whether myQueue<\/code> contains an element or waits for an element to be contained. However, the lock is only held inside wait()<\/code>, i.e. in get()<\/code> you cannot be sure that the element is still in myQueue<\/code>: another thread may get the lock and remove the element, resulting in undefined behavior on the call to myQueue.front()<\/code>.<\/li>
  2. If the copy\/move constructor of T<\/code> throws an exception, the ThreadSafeQueue<\/code> is in an inconsistent state: no member function is active, but the mutex is locked<\/li><\/ol>
    \u00a0<\/p>
    The fix is that Monitor::wait()<\/code> can only be called if a unique_lock<\/code> is held. This can be achieved, for example, by having Monitor<\/code> provide an appropriate (protected?) function that returns a suitable object and requests a reference to it in wait()<\/code>:<\/p><\/div><\/div><\/form><\/div><\/div><\/div><\/div><\/div><\/p>\n\n\n\n
    struct<\/span> Monitor {\n   using<\/span> Lock =<\/span> std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span>; \/\/ could be wrapper if you prefer<\/span>\n   [[nodiscard]] Lock receiveGuard() { return<\/span> Lock(monitMutex); }\n   template<\/span> <<\/span>typename<\/span> Predicate><\/span>\n   void<\/span> wait(Lock&<\/span> kerberos, Predicate pred) { monitCond.wait(kerberos, pred); }\n   \/\/ \u2026<\/span>\n};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nT ThreadSafeQueue<<\/span>T>::<\/span>get() {\n   auto<\/span> kerberos =<\/span> receiveGuard();\n   wait(kerberos, [this<\/span>]{ return<\/span> not myQueue.empty(); });\n   T rc =<\/span> std::<\/span>move(myQueue.front());\n   myqueue.pop();\n   return<\/span> rc;\n}\n<\/pre><\/div>\n\n\n\n
    This version corrects the exception problem for get()<\/code>. For add()<\/code> you can simply use the monitor object with a lock_guard<\/code>:<\/p>\n\n\n\n
    template<\/span> <<\/span>typename<\/span> T><\/span>\nvoid<\/span> add(T val) {\n   {\n        std::<\/span>lock_guard<<\/span>Monitor><\/span> kerberos(*<\/span>this<\/span>);\n        myqueue.push(std::<\/span>move(val));\n    }\n    notify_one();\n}\n<\/pre><\/div>\n\n\n\n
    I would probably wrap the notification in a “SendGuard<\/code>” that contains a lock_guard<\/code> and a reference to the condition_variable<\/code> and sends the notification upon destruction:<\/p>\n\n\n\n
    class<\/span> SendGuard<\/span> {\n    friend<\/span> class<\/span> Monitor<\/span>;\n    using<\/span> deleter =<\/span> decltype([](auto<\/span>&<\/span> cond){ cond-><\/span>notify_one(); });\n    std::<\/span>unique_ptr<<\/span>std::<\/span>condition_variable, deleter><\/span> notifier;\n    std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> kerberos;\n    SendGuard(auto<\/span>&<\/span> mutex, auto<\/span>&<\/span> cond):<\/span> notifier(&<\/span>cond), kerberos(mutex) {}\n};\n<\/pre><\/div>\n\n\n\n
    The move constructor and destructor should still be public and represent the whole interface! This would also make it much easier to use in<\/strong> add()<\/code>:<\/em><\/p>\n\n\n\n
    template<\/span> <<\/span>typename<\/span> T><\/span>\nvoid<\/span> add(T val) {\n   auto<\/span> kerberos =<\/span> sendGuard();\n   myqueue.push(val);\n}\n<\/pre><\/div>\n\n\n\n
    Finally, here is the full implementation of Dietmar. The numbers correspond to the numbers in my monitorObjec.cpp example.<\/em><\/strong><\/p>\n\n\n\n
    \/\/ threadsafequeue1.cpp<\/span>\n\n#include <condition_variable><\/span>\n#include <functional><\/span>\n#include <queue><\/span>\n#include <iostream><\/span>\n#include <mutex><\/span>\n#include <random><\/span>\n#include <thread><\/span>\n\nclass<\/span> Monitor<\/span> {\npublic:<\/span>\n    using<\/span> Lock =<\/span> std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span>;\n    [[nodiscard]] Lock receiveGuard() {\n        return<\/span> Lock(monitMutex);\n    }\n\n    template<\/span> <<\/span>typename<\/span> Predicate><\/span>\n    void<\/span> wait(Lock&<\/span> kerberos, Predicate pred) {\n        monitCond.wait(kerberos, pred);\n    }\n\n    class<\/span> SendGuard<\/span> {\n        friend<\/span> class<\/span> Monitor<\/span>;\n        using<\/span> deleter =<\/span> decltype([](auto<\/span>*<\/span> cond){ cond-><\/span>notify_one(); });\n        std::<\/span>unique_ptr<<\/span>std::<\/span>condition_variable, deleter><\/span> notifier;\n        std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> kerberos;\n        SendGuard(auto<\/span>&<\/span> mutex, auto<\/span>&<\/span> cond):<\/span> notifier(&<\/span>cond), kerberos(mutex) {}\n    };\n\n    SendGuard sendGuard<\/span>() { return<\/span> {monitMutex, monitCond}; }\n    \nprivate:<\/span>\n    mutable<\/span> std::<\/span>mutex monitMutex;\n    mutable<\/span> std::<\/span>condition_variable monitCond;\n};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>                                  \/\/ (1)<\/span>\nclass<\/span> ThreadSafeQueue<\/span>:<\/span> public<\/span> Monitor {\n public:<\/span>\n    void<\/span> add(T val){ \n        auto<\/span> kerberos =<\/span> sendGuard();\n        myQueue.push(val);                             \/\/ (6)<\/span>\n    }\n    \n    T get(){ \n        auto<\/span> kerberos =<\/span> receiveGuard();\n        wait(kerberos, [this<\/span>] { return<\/span> !<\/span> myQueue.empty(); } );  \/\/ (2)<\/span>\n        auto<\/span> val =<\/span> myQueue.front();                    \/\/ (4)<\/span>\n        myQueue.pop();                                 \/\/ (5)<\/span>\n        return<\/span> val;\n    }\n\nprivate:<\/span>\n    std::<\/span>queue<<\/span>T><\/span> myQueue;                            \/\/ (3)<\/span>\n};\n\n\nclass<\/span> Dice<\/span> {\npublic:<\/span>\n    int<\/span> operator<\/span>()(){ return<\/span> rand(); }\nprivate:<\/span>\n    std::<\/span>function<<\/span>int<\/span>()><\/span> rand =<\/span> std::<\/span>bind(std::<\/span>uniform_int_distribution<><\/span>(1<\/span>, 6<\/span>), \n                                          std::<\/span>default_random_engine());\n};\n\n\nint<\/span> main<\/span>(){\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    constexpr auto<\/span> NumberThreads =<\/span> 100<\/span>;\n    \n    ThreadSafeQueue<<\/span>int<\/span>><\/span> safeQueue;                      \/\/ (7)<\/span>\n\n    auto<\/span> addLambda =<\/span> [&<\/span>safeQueue](int<\/span> val){ safeQueue.add(val);          \/\/ (8)<\/span>\n                                            std::<\/span>cout <<<\/span> val <<<\/span> " "<\/span>\n                                            <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> "; "<\/span>; \n                                          }; \n    auto<\/span> getLambda =<\/span> [&<\/span>safeQueue]{ safeQueue.get(); };  \/\/ (9)<\/span>\n\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> addThreads(NumberThreads);\n    Dice dice;\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> addThreads) thr =<\/span> std::<\/span>thread<\/span>(addLambda, dice());\n\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> getThreads(NumberThreads);\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> getThreads) thr =<\/span> std::<\/span>thread<\/span>(getLambda);\n\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> addThreads) thr.join();\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> getThreads) thr.join();\n    \n    std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n     \n}\n<\/pre><\/div>\n\n\n\n
    As a result of the discussion above, Frank has proposed the following version below, which has a consistent and easy-to-use interface for Monitor.<\/p>\n\n\n\n
    \/\/ threadSafeQueue.cpp<\/span>\n\n#ifndef INCLUDED_PATTERNS_MONITOR2_MONITOR_HPP<\/span>\n#define INCLUDED_PATTERNS_MONITOR2_MONITOR_HPP<\/span>\n\n#include <atomic><\/span>\n#include <algorithm><\/span>\n#include <condition_variable><\/span>\n#include <deque><\/span>\n#include <iterator><\/span>\n#include <mutex><\/span>\n#include <stdexcept><\/span>\n#include <thread><\/span>\n#include <vector><\/span>\n\n\nclass<\/span> Monitor<\/span> {\npublic:<\/span>\n    struct<\/span> UnlockAndNotify {\n        std::<\/span>mutex d_mutex;\n        std::<\/span>condition_variable d_condition;\n\n        void<\/span> lock<\/span>() { d_mutex.lock(); }\n        void<\/span> unlock<\/span>() { d_mutex.unlock(); d_condition.notify_one(); }\n    };\n\nprivate:<\/span>\n    UnlockAndNotify d_combined;\n\npublic:<\/span>\n    std::<\/span>unique_lock<<\/span>UnlockAndNotify><\/span> makeLockWithNotify() {\n        return<\/span> std::<\/span>unique_lock{d_combined};\n    }\n\n    template<\/span> <<\/span>typename<\/span> PRED><\/span>\n    std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> makeLockWithWait(PRED waitForCondition) {\n        std::<\/span>unique_lock lock{d_combined.d_mutex};\n        d_combined.d_condition.wait(lock, waitForCondition);\n        return<\/span> lock;\n    }\n};\n\nclass<\/span> ThreadQueue<\/span> {\n    Monitor d_monitor;\n    std::<\/span>deque<<\/span>int<\/span>><\/span> d_numberQueue;\n\n    auto<\/span> makeLockWhenNotEmpty<\/span>() {\n        return<\/span> d_monitor.makeLockWithWait([this<\/span>] { return<\/span> !<\/span>d_numberQueue.empty(); });\n    }\n\npublic:<\/span>\n    void<\/span> addNumber<\/span>(int<\/span> number) {\n        const<\/span> auto<\/span> lock =<\/span> d_monitor.makeLockWithNotify();\n        d_numberQueue.push_back(number);\n    }\n\n    int<\/span> removeNumber<\/span>() {\n        const<\/span> auto<\/span> lock =<\/span> makeLockWhenNotEmpty();\n        const<\/span> auto<\/span> number =<\/span> d_numberQueue.front();\n        d_numberQueue.pop_front();\n        return<\/span> number;\n    }\n};\n\n#endif<\/span>\n\nint<\/span> main<\/span>() {\n   ThreadQueue queue;\n   std::<\/span>atomic<<\/span>int<\/span>><\/span> sharedSum{};\n   std::<\/span>atomic<<\/span>int<\/span>><\/span> sharedCounter{};\n\n   std::<\/span>vector<<\/span>std::<\/span>jthread><\/span> threads;\n   threads.reserve(200<\/span>);\n   std::<\/span>generate_n(std::<\/span>back_inserter(threads), 100<\/span>, [&<\/span>] {\n       return<\/span> std::<\/span>jthread{[&<\/span>] { sharedSum +=<\/span> queue.removeNumber(); }};\n   });\n   std::<\/span>generate_n(std::<\/span>back_inserter(threads), 100<\/span>, [&<\/span>] {\n       return<\/span> std::<\/span>jthread{[&<\/span>] { queue.addNumber(++<\/span>sharedCounter); }};\n   });\n\n   threads.clear(); \/\/ wait for all threads to finish<\/span>\n   if<\/span> (sharedSum.load() !=<\/span> 5050<\/span>) {\n       throw<\/span> std::<\/span>logic_error("Wrong result for sum of 1..100"<\/span>);\n   }\n}\n<\/pre><\/div>\n\n\n\n
    The implementation of the monitor pattern here is based on the flexibility of std::unique_lock<\/code> through its template parameter.  All of the std RAII lock guards can be used with any class that has lock()<\/code> and unlock()<\/code> methods.  The UnlockAndNotify<\/code> class implements this interface and notifies its condition variable from within the unlock()<\/code> method.  On top of that, the Monitor<\/code> class provides a reduced public interface to create two different kinds of locks, one with notification and one without, by creating a std::unique_lock<\/code> on either the whole UnlockAndNotify<\/code> instance or just the contained std::mutex<\/code>.

    On the choice of std::unique_lock<\/code> versus std::lock_guard<\/code> I (Frank<\/em><\/strong>) prefer the unique_lock<\/code> in the interface.  This choice allows the user of the Monitor<\/code> class more flexibility.  I value this flexibility higher than a possible performance difference to lock_guard<\/code> which anyway needs to be measured first.  I acknowledge that the given examples don’t make use of this extra flexibility.<\/p>\n\n\n\n
    Afterward, Dietmar further developed Frank’s idea: here, the protected data is kept in the Monitor, making it harder to access it unprotected.<\/em><\/strong><\/p>\n\n\n\n
    \/\/ threadsafequeue2.cpp<\/span>\n\n#ifndef INCLUDED_PATTERNS_MONITOR3_MONITOR_HPP<\/span>\n#define INCLUDED_PATTERNS_MONITOR3_MONITOR_HPP<\/span>\n\n#include <algorithm><\/span>\n#include <atomic><\/span>\n#include <condition_variable><\/span>\n#include <deque><\/span>\n#include <functional><\/span>\n#include <iostream><\/span>\n#include <iterator><\/span>\n#include <mutex><\/span>\n#include <random><\/span>\n#include <stdexcept><\/span>\n#include <thread><\/span>\n#include <tuple><\/span>\n#include <vector><\/span>\n\nnamespace<\/span> patterns::<\/span>monitor3 {\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nclass<\/span> Monitor<\/span> {\npublic:<\/span>\n   struct<\/span> UnlockAndNotify {\n       std::<\/span>mutex d_mutex;\n       std::<\/span>condition_variable d_condition;\n   \n       void<\/span> lock<\/span>() { d_mutex.lock(); }\n       void<\/span> unlock<\/span>() { d_mutex.unlock(); d_condition.notify_one(); }\n   };\n\nprivate:<\/span>\n   mutable<\/span> UnlockAndNotify d_combined;\n   mutable<\/span> T               d_data;\n\npublic:<\/span>\n   std::<\/span>tuple<<\/span>T&<\/span>, std::<\/span>unique_lock<<\/span>UnlockAndNotify>><\/span> makeProducerLock() const<\/span> {\n       return<\/span> { d_data, std::<\/span>unique_lock{d_combined} };\n   }\n\n   template<\/span> <<\/span>typename<\/span> PRED><\/span>\n   std::<\/span>tuple<<\/span>T&<\/span>, std::<\/span>unique_lock<<\/span>std::<\/span>mutex>><\/span> makeConsumerLockWhen(PRED predicate) const<\/span> {\n       std::<\/span>unique_lock lock{d_combined.d_mutex};\n       d_combined.d_condition.wait(lock, [this<\/span>, predicate]{ return<\/span> predicate(d_data); });\n       return<\/span> { d_data, std::<\/span>move(lock) };\n   }\n};\n\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\nclass<\/span> ThreadQueue<\/span> {\n   Monitor<<\/span>std::<\/span>deque<<\/span>T>><\/span> d_monitor;\n\npublic:<\/span>\n   void<\/span> add<\/span>(T number) {\n       auto<\/span>[numberQueue, lock] =<\/span> d_monitor.makeProducerLock();\n       numberQueue.push_back(number);\n   }\n\n   T remove<\/span>() {\n       auto<\/span>[numberQueue, lock] =<\/span> d_monitor.makeConsumerLockWhen([](auto<\/span>&<\/span> numberQueue) { return<\/span> !<\/span>numberQueue.empty(); });\n       const<\/span> auto<\/span> number =<\/span> numberQueue.front();\n       numberQueue.pop_front();\n       return<\/span> number;\n   }\n};\n}\n\n#endif<\/span>\n\nclass<\/span> Dice<\/span> {\npublic:<\/span>\n    int<\/span> operator<\/span>()(){ return<\/span> rand(); }\nprivate:<\/span>\n    std::<\/span>function<<\/span>int<\/span>()><\/span> rand =<\/span> std::<\/span>bind(std::<\/span>uniform_int_distribution<><\/span>(1<\/span>, 6<\/span>), \n                                          std::<\/span>default_random_engine());\n};\n\nint<\/span> main<\/span>(){\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    constexpr auto<\/span> NumberThreads =<\/span> 100<\/span>;\n    \n    patterns::<\/span>monitor3::<\/span>ThreadQueue<<\/span>int<\/span>><\/span> safeQueue;                     \n\n    auto<\/span> addLambda =<\/span> [&<\/span>safeQueue](int<\/span> val){ safeQueue.add(val);         \n                                            std::<\/span>cout <<<\/span> val <<<\/span> " "<\/span>\n                                            <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> "; "<\/span>; \n                                          }; \n    auto<\/span> getLambda =<\/span> [&<\/span>safeQueue]{ safeQueue.remove(); };  \n\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> addThreads(NumberThreads);\n    Dice dice;\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> addThreads) thr =<\/span> std::<\/span>thread<\/span>(addLambda, dice());\n\n    std::<\/span>vector<<\/span>std::<\/span>thread<\/span>><\/span> getThreads(NumberThreads);\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> getThreads) thr =<\/span> std::<\/span>thread<\/span>(getLambda);\n\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> addThreads) thr.join();\n    for<\/span> (auto<\/span>&<\/span> thr:<\/span> getThreads) thr.join();\n    \n    std::<\/span>cout <<<\/span> "<\/span>\\n\\n<\/span>"<\/span>;\n     \n}\n<\/pre><\/div>\n\n\n\n
    Once more, thanks a lot to Frank<\/strong> and Dietmar<\/strong>. I didn’t want to prove, with my erroneous implementation of a thread-safe queue in my previous post, that concurrency is hard to get right. I’m particularly annoyed that I don’t put the mutex inside a lock (error 2). I teach this in my C++ classes: NNM (No Naked Mutex).<\/p>\n\n\n\n
    What’s next?<\/h2>\n\n\n\n
    In my next post, I dive into the future of C++: C++23.<\/p>\n","protected":false},"excerpt":{"rendered":"
    In my last post “Monitor Object”  I implemented a thread-safe queue. I made two serious errors. Sorry. Today, I will fix these issues. First, I want to show you again the erroneous implementation from my last post to understand the context. \/\/ monitorObject.cpp #include <condition_variable> #include <functional> #include <queue> #include <iostream> #include <mutex> #include <random> […]<\/p>\n","protected":false},"author":21,"featured_media":7662,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[379],"tags":[],"class_list":["post-7661","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-patterns"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7661","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=7661"}],"version-history":[{"count":5,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7661\/revisions"}],"predecessor-version":[{"id":8039,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/7661\/revisions\/8039"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/7662"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=7661"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=7661"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=7661"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}