%threads.entities; ]>

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.