thread safe object state manipulation in c++11 - c++

Question

I am trying to do the following in a multi-threaded environment (it does not implement the solution correctly at the moment but you can get the intent)
struct object {
object() : numReaders(0) {}
void tryRead() {
numReaders++;
if(!isDestroyed) {
// do something
}
numReaders--;
}
void destroy() {
if(numReaders == 0) {
// <- if there is a reader here we have a problem
isDestroyed = 1;
} else {
// wait until all readers are done and destroy
}
}
std::atomic<int> numReaders;
std::atomic<int> isDestroyed;
};
this sure looks like a std::shared_mutex or a reader/writer lock problem. Is this particular problem solvable in the context of c++11 in a clean and short way (without copying implementations from c++14 or smth) and without using third party libraries?
A solution attempt:
OK, so I wrote something like this (destroy in the case above is a writer, and try read is a reader). There are 3 solutions, the 2nd and 3rd one trying to create less boiler plate code and 3rd also tried to be exception safe (if an exception is thrown no deadlock occurs). However, running 2nd solution works just fine, the 3rd one gets a deadlock, although seemingly 3rd is just a slighly modified 2nd, relying on the fact that C++ would call destructor at the end of the scope.
#include <mutex>
#include <atomic>
#include <thread>
#include <vector>
#include <iostream>
#include <condition_variable>
//--------------------------------------------------------------------------
// Reader/writer solution 1
//--------------------------------------------------------------------------
class Doer {
std::mutex requestLock_;
std::atomic<int> numRequests_;
std::condition_variable hasNoRequests_;
public:
Doer()
: numRequests_(0)
{
}
void reader()
{
{
std::lock_guard<std::mutex> guard(requestLock_);
numRequests_++;
}
std::cout << "read" << std::endl;
{
std::lock_guard<std::mutex> guard(requestLock_);
numRequests_--;
// notify a potential writer that read is over
}
hasNoRequests_.notify_one();
}
void writer()
{
std::unique_lock<std::mutex> guard(requestLock_, std::defer_lock_t());
hasNoRequests_.wait(guard, [this]() {return numRequests_ == 0; });
std::cout << std::endl << "write" << std::endl;
guard.unlock();
// wake up only 1 writer
hasNoRequests_.notify_one();
}
};
//--------------------------------------------------------------------------
// Reader/writer solution 2
//--------------------------------------------------------------------------
class SmartDoer {
std::mutex requestLock_;
std::atomic<int> numRequests_;
std::condition_variable hasNoRequests_;
std::function<void()> startRead_;
std::function<void()> finishRead_;
std::function<std::unique_lock<std::mutex>()> startWrite_;
std::function<void(std::unique_lock<std::mutex>)> finishWrite_;
public:
SmartDoer() : numRequests_(0)
{
startRead_ = [this]() {
std::lock_guard<std::mutex> guard(requestLock_);
std::cout << "start read" << std::endl;
numRequests_++;
};
finishRead_ = [this]() {
{
std::lock_guard<std::mutex> guard(requestLock_);
numRequests_--;
std::cout << "finish read" << std::endl;
}
// notify a potential writer that read is over
hasNoRequests_.notify_one();
};
startWrite_ = [this]() {
std::unique_lock<std::mutex> guard(requestLock_, std::defer_lock_t());
hasNoRequests_.wait(guard, [this]() {return numRequests_ == 0; });
std::cout << "start write" << std::endl;
return guard;
};
finishWrite_ = [this](std::unique_lock<std::mutex>&& guard) {
std::cout << "finish write" << std::endl;
guard.unlock();
// wake up only 1 writer
hasNoRequests_.notify_one();
};
}
void reader()
{
startRead_();
std::cout << "read" << std::endl;
finishRead_();
}
void writer()
{
auto result = startWrite_();
std::cout << std::endl << "write" << std::endl;
finishWrite_(std::move(result));
}
};
//--------------------------------------------------------------------------
// Reader/writer solution 3
//--------------------------------------------------------------------------
template <typename Start, typename Finish>
class ScopeGuard {
public:
ScopeGuard(Start& start, Finish& finish)
: start_(start)
, finish_(finish)
, engaged_(true)
{
auto result_ = start_();
}
~ScopeGuard()
{
if (engaged_) {
std::bind(finish_, std::move(result_));
}
}
void release()
{
engaged_ = false;
}
private:
std::result_of<Start()> result_;
Start start_;
Finish finish_;
bool engaged_;
};
template <typename Start, typename Finish>
class VoidScopeGuard {
public:
VoidScopeGuard(Start& start, Finish& finish)
: start_(start)
, finish_(finish)
, engaged_(true)
{
start_();
}
~VoidScopeGuard()
{
if (engaged_) {
finish_();
}
}
void release()
{
engaged_ = false;
}
private:
Start start_;
Finish finish_;
bool engaged_;
};
class TheSmartestDoer {
std::mutex requestLock_;
std::atomic<int> numRequests_;
std::condition_variable hasNoRequests_;
std::function<void()> startRead_;
std::function<void()> finishRead_;
std::function<std::unique_lock<std::mutex>()> startWrite_;
std::function<void(std::unique_lock<std::mutex>&&)> finishWrite_;
public:
TheSmartestDoer() : numRequests_(0)
{
startRead_ = [this]() {
std::lock_guard<std::mutex> guard(requestLock_);
std::cout << "start read" << std::endl;
numRequests_++;
};
finishRead_ = [this]() {
{
std::lock_guard<std::mutex> guard(requestLock_);
numRequests_--;
std::cout << "finish read" << std::endl;
}
// notify a potential writer that read is over
hasNoRequests_.notify_one();
};
startWrite_ = [this]() {
std::unique_lock<std::mutex> guard(requestLock_, std::defer_lock_t());
hasNoRequests_.wait(guard, [this]() {return numRequests_ == 0; });
std::cout << "start write" << std::endl;
return guard;
};
finishWrite_ = [this](std::unique_lock<std::mutex>&& guard) {
std::cout << "finish write" << std::endl;
guard.unlock();
// wake up only 1 writer
hasNoRequests_.notify_one();
};
}
void reader()
{
VoidScopeGuard<decltype(startRead_), decltype(finishRead_)> guard(startRead_, finishRead_);
std::cout << "read" << std::endl;
}
void writer()
{
ScopeGuard<decltype(startWrite_), decltype(finishWrite_)> guard(startWrite_, finishWrite_);
std::cout << std::endl << "write" << std::endl;
}
};
int main()
{
TheSmartestDoer doit;
std::vector<std::thread> write(10000);
for (int i = 0; i < write.size(); i++) {
write[i] = std::thread(&TheSmartestDoer::writer, &doit);
}
std::vector<std::thread> read(10000);
for (int i = 0; i < read.size(); i++) {
read[i] = std::thread(&TheSmartestDoer::reader, &doit);
}
for (int i = 0; i < write.size(); i++) {
write[i].join();
}
for (int i = 0; i < read.size(); i++) {
read[i].join();
}
return 0;
}

Answer 1

The simplest way is to use weak reference paradigm, that is object's reference which do not prevent object from being deleted. c++11 has std::weak_ptr<> class for that paradigm:
#include <memory>
class Object {...};
std::weak_ptr<Object> wptr; // Weak reference for use in (reader) threads
int main()
{
std::shared_ptr<Object> sptr; // Strong reference, determine lifetime of the object
//...
sptr = std::make_shared<Object>(...);// Create object and store reference to it
wptr = sptr;
//...
sptr.reset(); // Mark object to be destroyed. Since that moment weak reference is treated as expired, no one can access object via it.
}
void reader()
{
std::shared_ptr<Object> tptr = wptr.lock(); // Temporary create strong reference from the weak one
if(tptr)
{
// Do something with object. It won't be deleted while 'tptr' is alive
}
}
Both std::shared_ptr and std::weak_ptr are already prepared for multithreaded usage.