Specifies the inter-class sheduling policy to use when a set of threads try to obtain different types of locks simultaneously.

The only clock type supported by &Boost.Threads; is `TIME_UTC`. The epoch for `TIME_UTC` is 1970-01-01 00:00:00.

The `read_write_mutex` class is a model of the ReadWriteMutex concept.

The `read_write_mutex` class is a model of the ReadWriteMutex concept. It should be used to synchronize access to shared resources using Unspecified locking mechanics.

For classes that model related mutex concepts, see `try_read_write_mutex` and `timed_read_write_mutex`.

The `read_write_mutex` class supplies the following typedefs, which model the specified locking strategies:

Lock Name | Lock Concept
--- | ---
scoped_read_write_lock | ScopedReadWriteLock
scoped_read_lock | ScopedLock
scoped_write_lock | ScopedLock

The `read_write_mutex` class uses an Unspecified locking strategy, so attempts to recursively lock a `read_write_mutex` object or attempts to unlock one by threads that don't own a lock on it result in undefined behavior. This strategy allows implementations to be as efficient as possible on any given platform. It is, however, recommended that implementations include debugging support to detect misuse when `NDEBUG` is not defined.

Like all read/write mutex models in &Boost.Threads;, `read_write_mutex` has two types of scheduling policies, an inter-class sheduling policy between threads trying to obtain different types of locks and an intra-class sheduling policy between threads trying to obtain the same type of lock. The `read_write_mutex` class allows the programmer to choose what inter-class sheduling policy will be used; however, like all read/write mutex models, `read_write_mutex` leaves the intra-class sheduling policy as Unspecified.

Self-deadlock is virtually guaranteed if a thread tries to lock the same `read_write_mutex` multiple times unless all locks are read-locks (but see below)

`boost::noncopyable` Exposition only
`boost::noncopyable` Exposition only
implementation-defined
implementation-defined
implementation-defined
boost::read_write_scheduling_policy
Constructs a `read_write_mutex` object.
*this
is in an unlocked state.
Destroys a `read_write_mutex` object.
*this
is in an unlocked state.
Danger: Destruction of a locked mutex is a serious programming error resulting in undefined behavior such as a program crash.

The `try_read_write_mutex` class is a model of the TryReadWriteMutex concept.

The `try_read_write_mutex` class is a model of the TryReadWriteMutex concept. It should be used to synchronize access to shared resources using Unspecified locking mechanics.

For classes that model related mutex concepts, see `read_write_mutex` and `timed_read_write_mutex`.

The `try_read_write_mutex` class supplies the following typedefs, which model the specified locking strategies:

Lock Name | Lock Concept
--- | ---
scoped_read_write_lock | ScopedReadWriteLock
scoped_try_read_write_lock | ScopedTryReadWriteLock
scoped_read_lock | ScopedLock
scoped_try_read_lock | ScopedTryLock
scoped_write_lock | ScopedLock
scoped_try_write_lock | ScopedTryLock

The `try_read_write_mutex` class uses an Unspecified locking strategy, so attempts to recursively lock a `try_read_write_mutex` object or attempts to unlock one by threads that don't own a lock on it result in undefined behavior. This strategy allows implementations to be as efficient as possible on any given platform. It is, however, recommended that implementations include debugging support to detect misuse when `NDEBUG` is not defined.

Like all read/write mutex models in &Boost.Threads;, `try_read_write_mutex` has two types of scheduling policies, an inter-class sheduling policy between threads trying to obtain different types of locks and an intra-class sheduling policy between threads trying to obtain the same type of lock. The `try_read_write_mutex` class allows the programmer to choose what inter-class sheduling policy will be used; however, like all read/write mutex models, `try_read_write_mutex` leaves the intra-class sheduling policy as Unspecified.

Self-deadlock is virtually guaranteed if a thread tries to lock the same `try_read_write_mutex` multiple times unless all locks are read-locks (but see below)

`boost::noncopyable` Exposition only
implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
boost::read_write_scheduling_policy
Constructs a `try_read_write_mutex` object.
*this
is in an unlocked state.
Destroys a `try_read_write_mutex` object.
*this
is in an unlocked state.
Danger: Destruction of a locked mutex is a serious programming error resulting in undefined behavior such as a program crash.

The `timed_read_write_mutex` class is a model of the TimedReadWriteMutex concept.

The `timed_read_write_mutex` class is a model of the TimedReadWriteMutex concept. It should be used to synchronize access to shared resources using Unspecified locking mechanics.

For classes that model related mutex concepts, see `read_write_mutex` and `try_read_write_mutex`.

The `timed_read_write_mutex` class supplies the following typedefs, which model the specified locking strategies:

Lock Name | Lock Concept
--- | ---
scoped_read_write_lock | ScopedReadWriteLock
scoped_try_read_write_lock | ScopedTryReadWriteLock
scoped_timed_read_write_lock | ScopedTimedReadWriteLock
scoped_read_lock | ScopedLock
scoped_try_read_lock | ScopedTryLock
scoped_timed_read_lock | ScopedTimedLock
scoped_write_lock | ScopedLock
scoped_try_write_lock | ScopedTryLock
scoped_timed_write_lock | ScopedTimedLock

The `timed_read_write_mutex` class uses an Unspecified locking strategy, so attempts to recursively lock a `timed_read_write_mutex` object or attempts to unlock one by threads that don't own a lock on it result in undefined behavior. This strategy allows implementations to be as efficient as possible on any given platform. It is, however, recommended that implementations include debugging support to detect misuse when `NDEBUG` is not defined.

Like all read/write mutex models in &Boost.Threads;, `timed_read_write_mutex` has two types of scheduling policies, an inter-class sheduling policy between threads trying to obtain different types of locks and an intra-class sheduling policy between threads trying to obtain the same type of lock. The `timed_read_write_mutex` class allows the programmer to choose what inter-class sheduling policy will be used; however, like all read/write mutex models, `timed_read_write_mutex` leaves the intra-class sheduling policy as Unspecified.

Self-deadlock is virtually guaranteed if a thread tries to lock the same `timed_read_write_mutex` multiple times unless all locks are read-locks (but see below)

implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
implementation-defined
boost::read_write_scheduling_policy
Constructs a `timed_read_write_mutex` object.
*this
is in an unlocked state.
Destroys a `timed_read_write_mutex` object.
*this
is in an unlocked state.
Danger: Destruction of a locked mutex is a serious programming error resulting in undefined behavior such as a program crash.