The ReaderWriterMutex concept extends the Mutex Concept to include the notion of reader-writer locks. It introduces a boolean parameter write that specifies whether a writer lock (write =true) or reader lock (write =false) is being requested. Multiple reader locks can be held simultaneously on a ReaderWriterMutex if it does not have a writer lock on it. A writer lock on a ReaderWriterMutex excludes all other threads from holding a lock on the mutex at the same time.
The following table shows the requirements for a ReaderWriterMutex RW. They form a superset of the Mutex Concept.
Pseudo-Signature |
Semantics |
---|---|
RW() |
Construct unlocked mutex. |
~RW() |
Destroy unlocked mutex. |
typename RW::scoped_lock |
Corresponding scoped-lock type. |
RW::scoped_lock() |
Construct lock without acquiring mutex. |
RW::scoped_lock(RW&, bool write=true) |
Construct lock and acquire lock on mutex. |
RW::~scoped_lock() |
Release lock (if acquired). |
RW::scoped_lock::acquire(RW&,bool write=true) |
Acquire lock on mutex. |
bool RW::scoped_lock::try_acquire(RW&, bool write=true) |
Try to acquire lock on mutex. Return true if lock acquired, false otherwise. |
RW::scoped_lock::release() |
Release lock. |
bool RW::scoped_lock::upgrade_to_writer() |
Change reader lock to writer lock. |
bool RW::scoped_lock::downgrade_to_reader() |
Change writer lock to reader lock. |
static const bool RW::is_rw_mutex = true |
True. |
static const bool RW::is_recursive_mutex |
True if mutex is recursive; false otherwise. For all current reader-writer mutexes, false. |
static const bool RW::is_fair_mutex |
True if mutex is fair; false otherwise. |
Member | Description |
---|---|
Model Types |
Classes spin_rw_mutex and queuing_rw_mutex model the ReaderWriterMutex concept. |
ReaderWriterMutex() |
Constructs unlocked ReaderWriterMutex. |
~ReaderWriterMutex() |
Destroys unlocked ReaderWriterMutex. The effect of destroying a locked ReaderWriterMutex is undefined. |
ReaderWriterMutex::scoped_lock() |
Constructs a scoped_lock object that does not hold a lock on any mutex. |
ReaderWriterMutex::scoped_lock( ReaderWriterMutex& rw, bool write =true) |
Constructs a scoped_lock object that acquires a lock on mutex rw. The lock is a writer lock if write is true; a reader lock otherwise. |
ReaderWriterMutex::~scoped_lock() |
If the object holds a lock on a ReaderWriterMutex, releases the lock. |
void ReaderWriterMutex:: scoped_lock:: acquire( ReaderWriterMutex& rw, bool write=true ) |
Acquires a lock on mutex rw. The lock is a writer lock if write is true; a reader lock otherwise. |
bool ReaderWriterMutex:: scoped_lock::try_acquire( ReaderWriterMutex& rw, bool write=true ) |
Attempts to acquire a lock on mutex rw. The lock is a writer lock if write is true; a reader lock otherwise. Returns: true if the lock is acquired, false otherwise. |
void ReaderWriterMutex:: scoped_lock::release() |
Releases lock. The effect is undefined if no lock is held. Returns: false if lock was released in favor of another upgrade request and then reacquired; true otherwise. |
bool ReaderWriterMutex:: scoped_lock::upgrade_to_writer() |
Changes reader lock to a writer lock. The effect is undefined if the object does not already hold a reader lock. Returns: false if lock was released and reacquired; true otherwise. |
bool ReaderWriterMutex:: scoped_lock::downgrade_to_reader() |
Changes writer lock to a reader lock. The effect is undefined if the object does not already hold a writer lock. Returns: false if lock was released and reacquired; true otherwise. Intel's current implementations for spin_rw_mutex and queuing_rw_mutex always return true. Different implementations might sometimes return false. |