I'm practicing to write c++11/14 and I implemented a RW lock. Does everything look ok?
class RWLock {
public:
void readLock() {
std::unique_lock<std::mutex> lock(mutex);
waitingReaders.wait(lock, [this]{!writer && queuedWriters == 0});
++readers;
}
void readUnlock() {
std::unique_lock<std::mutex> lock(mutex);
--readers;
if (readers == 0 && queuedWriters > 0) {
lock.unlock();
waitingWriters.notify_one();
}
}
void writeLock() {
std::unique_lock<std::mutex> lock(mutex);
++queuedWriters;
waitingWriters.wait(lock, [this]{!writer && readers == 0});
--queuedWriters;
writer = true;
}
void writeUnlock() {
std::unique_lock<std::mutex> lock(mutex);
if(queuedWriters > 0) {
lock.unlock();
waitingWriters.notify_one();
} else {
writer = false;
lock.unlock();
waitingReaders.notify_all();
}
}
private:
std::mutex mutex;
std::condition_variable waitingReaders;
std::condition_variable waitingWriters;
int readers = 0;
int queuedWriters = 0;
bool writer = false;
};
In particular:
Do I really need to take a lock in my WriteUnlock() method? It looks like all I'm doing is unlock right away.
And is it recommended to perform a lock.unlock() before I do a notify_one or a notify_all ?
Does performing a condition_variable.wait(lock, lambda) where the lambda is true cause a performance loss? Like potentially in the readLock() method
