trjhtr

This is my attempt at dealing with spurious wakeups: A new class which replaced std::condition_variable in my code.

Some questions which came to my mind are (and I hope CR is the right place for that):

1. Is this actually effective? Or will I run into concurrency-related problems?


2. Would inheriting std::condition_variable be better than delegation?


3. Is it better to use bool guarded by a std::mutex or std::atomic<bool>?

This is the class:

#include <mutex>
#include <condition_variable>

class Condition 
private:
 std::condition_variable _condition; // Delegation
 bool _waiting;
 std::mutex _internalMutex;
public:
 Condition()
 : _waiting(false) 

 void wait(std::unique_lock<std::mutex>& lock)
 
 std::unique_lock<std::mutex> lock(_internalMutex);
 _waiting = true;
 _condition.wait(lock, [this]() return !_waiting; );
 

 template< class Rep, class Period >
 void wait_for(std::unique_lock<std::mutex>& lock,
 const std::chrono::duration<Rep, Period>& relTime)
 
 std::unique_lock<std::mutex> lock(_internalMutex);
 _waiting = true;
 _condition.wait_for(lock, relTime, [this]() return !_waiting; );
 

 template< class Clock, class Duration >
 void wait_until(std::unique_lock<std::mutex>& lock,
 const std::chrono::time_point<Clock, Duration>& timeoutTime)
 
 std::unique_lock<std::mutex> lock(_internalMutex);
 _waiting = true;
 _condition.wait_until(lock, timeoutTime, [this]() return !_waiting; );
 

 void notify_all()
 
 std::unique_lock<std::mutex> lock(_internalMutex);
 _waiting = false;
 _condition.notify_all();
 

 void notify_one()
 
 std::unique_lock<std::mutex> lock(_internalMutex);
 _waiting = false;
 _condition.notify_one();
 
;

The usage would be the same as with std::condition_variable (but without the typical caveat that you have to prevent spurious wakeups by encapsulating .wait() with a predicate check.