![]() |
Home | Libraries | People | FAQ | More |
unique_lockunique_lock()unique_lock(Lockable &
m)unique_lock(Lockable &
m,boost::adopt_lock_t)unique_lock(Lockable &
m,boost::defer_lock_t)unique_lock(Lockable &
m,boost::try_to_lock_t)unique_lock(shared_lock<mutex_type>&&
sl,
try_to_lock_t)unique_lock(shared_lock<mutex_type>&&,
const chrono::time_point<Clock, Duration>&)unique_lock(shared_lock<mutex_type>&&,
const chrono::duration<Rep, Period>&)unique_lock(Lockable &
m,boost::system_time const& abs_time)template <class Clock, class Duration>
unique_lock(Lockable &
m,const chrono::time_point<Clock, Duration>& abs_time)template <class Rep, class Period>
unique_lock(Lockable &
m,const chrono::duration<Rep, Period>& abs_time)~unique_lock()bool owns_lock() constLockable* mutex() const noexceptexplicit operator
bool()
constLockable* release()shared_lock - C++14shared_lock()shared_lock(Lockable &
m)shared_lock(Lockable &
m,boost::adopt_lock_t)shared_lock(Lockable &
m,boost::defer_lock_t)shared_lock(Lockable &
m,boost::try_to_lock_t)shared_lock(Lockable &
m,boost::system_time const& abs_time)~shared_lock()bool owns_lock() constLockable* mutex() constexplicit operator
bool()
constLockable* release()upgrade_lock - EXTENSIONupgrade_to_unique_lock
-- EXTENSIONscoped_try_lock --
DEPRECATED// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> namespace boost { template<typename Lockable> class unique_lock; template<typename Mutex> void swap(unique_lock <Mutex>& lhs, unique_lock <Mutex>& rhs); template<typename Lockable> class shared_lock; // C++14 template<typename Mutex> void swap(shared_lock<Mutex>& lhs,shared_lock<Mutex>& rhs); // C++14 template<typename Lockable> class upgrade_lock; // EXTENSION template<typename Mutex> void swap(upgrade_lock <Mutex>& lhs, upgrade_lock <Mutex>& rhs); // EXTENSION template <class Mutex> class upgrade_to_unique_lock; // EXTENSION }
unique_lock()unique_lock(Lockable &
m)unique_lock(Lockable &
m,boost::adopt_lock_t)unique_lock(Lockable &
m,boost::defer_lock_t)unique_lock(Lockable &
m,boost::try_to_lock_t)unique_lock(shared_lock<mutex_type>&&
sl,
try_to_lock_t)unique_lock(shared_lock<mutex_type>&&,
const chrono::time_point<Clock, Duration>&)unique_lock(shared_lock<mutex_type>&&,
const chrono::duration<Rep, Period>&)unique_lock(Lockable &
m,boost::system_time const& abs_time)template <class Clock, class Duration>
unique_lock(Lockable &
m,const chrono::time_point<Clock, Duration>& abs_time)template <class Rep, class Period>
unique_lock(Lockable &
m,const chrono::duration<Rep, Period>& abs_time)~unique_lock()bool owns_lock() constLockable* mutex() const noexceptexplicit operator
bool()
constLockable* release()// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template<typename Lockable> class unique_lock { public: typedef Lockable mutex_type; unique_lock() noexcept; explicit unique_lock(Lockable& m_); unique_lock(Lockable& m_,adopt_lock_t); unique_lock(Lockable& m_,defer_lock_t) noexcept; unique_lock(Lockable& m_,try_to_lock_t); #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION unique_lock(shared_lock<mutex_type>&& sl, try_to_lock_t); // C++14 template <class Clock, class Duration> unique_lock(shared_lock<mutex_type>&& sl, const chrono::time_point<Clock, Duration>& abs_time); // C++14 template <class Rep, class Period> unique_lock(shared_lock<mutex_type>&& sl, const chrono::duration<Rep, Period>& rel_time); // C++14 #endif template <class Clock, class Duration> unique_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t); template <class Rep, class Period> unique_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d); ~unique_lock(); unique_lock(unique_lock const&) = delete; unique_lock& operator=(unique_lock const&) = delete; unique_lock(unique_lock<Lockable>&& other) noexcept; explicit unique_lock(upgrade_lock<Lockable>&& other) noexcept; // EXTENSION unique_lock& operator=(unique_lock<Lockable>&& other) noexcept; void swap(unique_lock& other) noexcept; Lockable* release() noexcept; void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); explicit operator bool() const noexcept; bool owns_lock() const noexcept; mutex_type* mutex() const noexcept; #if defined BOOST_THREAD_USE_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO unique_lock(Lockable& m_,system_time const& target_time); template<typename TimeDuration> bool timed_lock(TimeDuration const& relative_time); bool timed_lock(::boost::system_time const& absolute_time); #endif };
boost::unique_lock is more complex than
boost::lock_guard: not only does it provide
for RAII-style locking, it also allows for deferring acquiring the lock
until the lock()
member function is called explicitly, or trying to acquire the lock in
a non-blocking fashion, or with a timeout. Consequently, unlock()
is only called in the destructor if the lock object has locked the Lockable object, or otherwise
adopted a lock on the Lockable object.
Specializations of boost::unique_lock model the TimedLockable concept if the supplied
Lockable type itself models
TimedLockable concept (e.g. boost::unique_lock<boost::timed_mutex>),
or the Lockable concept if the supplied
Lockable type itself models
Lockable concept (e.g. boost::unique_lock<boost::mutex>),
or the BasicLockable concept if the supplied
Lockable type itself models
BasicLockable concept.
An instance of boost::unique_lock is said to own
the lock state of a Lockable m
if mutex()
returns a pointer to m
and owns_lock()
returns true. If an object
that owns the lock state of a Lockable object is destroyed,
then the destructor will invoke mutex()->unlock().
The member functions of boost::unique_lock are not thread-safe.
In particular, boost::unique_lock is intended to model
the ownership of a Lockable object by a particular
thread, and the member functions that release ownership of the lock state
(including the destructor) must be called by the same thread that acquired
ownership of the lock state.
Creates a lock object with no associated mutex.
owns_lock()
returns false. mutex()
returns NULL.
Nothing.
Stores a reference to m.
Invokes m.lock().
owns_lock()
returns true. mutex()
returns &m.
Any exception thrown by the call to m.lock().
The current thread owns an exclusive lock on m.
Stores a reference to m.
Takes ownership of the lock state of m.
owns_lock()
returns true. mutex()
returns &m.
Nothing.
Stores a reference to m.
owns_lock()
returns false. mutex()
returns &m.
Nothing.
Stores a reference to m.
Invokes m.try_lock(),
and takes ownership of the lock state if the call returns true.
mutex()
returns &m.
If the call to try_lock()
returned true, then
owns_lock()
returns true, otherwise
owns_lock()
returns false.
Nothing.
The supplied Mutex
type must implement .
try_unlock_shared_and_lock()
Constructs an object of type boost::unique_lock. Let pm be the pointer to the mutex
and owns the ownership
state. Initializes pm
with nullptr and owns
with false. If sl. returns owns_lock()()false,
sets pm to the
return value of sl.release(). Else sl. returns owns_lock()()true,
and in this case if sl.mutex()->try_unlock_shared_and_lock() returns true,
sets pm to the
value returned by sl.release() and sets owns
to true.
If sl.owns_lock()
returns true and
sl.mutex()->try_unlock_shared_and_lock()
returns false, sl is not modified.
Nothing.
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
template <class Clock, class Duration> unique_lock(shared_lock<mutex_type>&& sl, const chrono::time_point<Clock, Duration>& abs_time);
The supplied Mutex
type shall implement .
try_unlock_shared_and_lock_until(abs_time)
Constructs an object of type , initializing
boost::unique_lockpm with nullptr and owns
with false. If sl.
returns owns_lock()()false,
sets pm to the
return value of sl.release(). Else sl. returns owns_lock()()true,
and in this case if sl.mutex()-> returns try_unlock_shared_and_lock_until(abs_time)true,
sets pm to the
value returned by sl.release() and sets owns
to true.
If sl.owns_lock()
returns true and
sl.mutex()->
returns try_unlock_shared_and_lock_until(abs_time)false,
sl is not modified.
Nothing.
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
template <class Rep, class Period> unique_lock(shared_lock<mutex_type>&& sl, const chrono::duration<Rep, Period>& rel_time)
The supplied Mutex
type shall implement .
try_unlock_shared_and_lock_for(rel_time)
Constructs an object of type , initializing
boost::unique_lockpm with nullptr and owns
with false. If sl.
returns owns_lock()()false,
sets pm to the
return value of sl.release(). Else sl.owns_lock() returns true,
and in this case if sl.mutex()-> returns try_unlock_shared_and_lock_for(rel_time)true,
sets pm to the
value returned by sl.release() and sets owns
to true.
If sl.owns_lock()
returns true and
sl.mutex()->
returns try_unlock_shared_and_lock_for(rel_time)false,
sl is not modified.
.
Nothing.
Available only if BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION
and BOOST_THREAD_PROVIDES_GENERIC_SHARED_MUTEX_ON_WIN
is defined on Windows platform
Stores a reference to m.
Invokes m.timed_lock(abs_time),
and takes ownership of the lock state if the call returns true.
mutex()
returns &m.
If the call to timed_lock()
returned true, then
owns_lock()
returns true, otherwise
owns_lock()
returns false.
Any exceptions thrown by the call to m.timed_lock(abs_time).
Stores a reference to m.
Invokes m., and takes ownership of the lock
state if the call returns try_lock_until(abs_time)true.
mutex()
returns &m.
If the call to try_lock_until returned
true, then owns_lock()
returns true, otherwise
owns_lock()
returns false.
Any exceptions thrown by the call to m..
try_lock_until(abs_time)
Stores a reference to m.
Invokes m.,
and takes ownership of the lock state if the call returns try_lock_for(rel_time)true.
mutex()
returns &m.
If the call to try_lock_for returned
true, then owns_lock()
returns true, otherwise
owns_lock()
returns false.
Any exceptions thrown by the call to m..
try_lock_for(rel_time)
Invokes mutex()-> unlock()
if owns_lock()
returns true.
Nothing.
true if the *this
owns the lock on the Lockable object associated
with *this.
Nothing.
A pointer to the Lockable object associated
with *this,
or NULL if there
is no such object.
Nothing.
.
owns_lock()()
Nothing.
The association between *this and the Lockable object is removed,
without affecting the lock state of the Lockable object. If owns_lock()
would have returned true,
it is the responsibility of the calling code to ensure that the
Lockable is correctly
unlocked.
A pointer to the Lockable object associated
with *this
at the point of the call, or NULL
if there is no such object.
Nothing.
*this
is no longer associated with any Lockable object. mutex()
returns NULL and
owns_lock()
returns false.
shared_lock()shared_lock(Lockable &
m)shared_lock(Lockable &
m,boost::adopt_lock_t)shared_lock(Lockable &
m,boost::defer_lock_t)shared_lock(Lockable &
m,boost::try_to_lock_t)shared_lock(Lockable &
m,boost::system_time const& abs_time)~shared_lock()bool owns_lock() constLockable* mutex() constexplicit operator
bool()
constLockable* release()// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template<typename Lockable> class shared_lock { public: typedef Lockable mutex_type; // Shared locking shared_lock(); explicit shared_lock(Lockable& m_); shared_lock(Lockable& m_,adopt_lock_t); shared_lock(Lockable& m_,defer_lock_t); shared_lock(Lockable& m_,try_to_lock_t); template <class Clock, class Duration> shared_lock(Mutex& mtx, const chrono::time_point<Clock, Duration>& t); template <class Rep, class Period> shared_lock(Mutex& mtx, const chrono::duration<Rep, Period>& d); ~shared_lock(); shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; shared_lock(shared_lock<Lockable> && other); shared_lock& operator=(shared_lock<Lockable> && other); void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); // Conversion from upgrade locking explicit shared_lock(upgrade_lock<Lockable> && other); // EXTENSION // Conversion from exclusive locking explicit shared_lock(unique_lock<Lockable> && other); // Setters void swap(shared_lock& other); mutex_type* release() noexcept; // Getters explicit operator bool() const; bool owns_lock() const; mutex_type mutex() const; #if defined BOOST_THREAD_USE_DATE_TIME || defined BOOST_THREAD_DONT_USE_CHRONO shared_lock(Lockable& m_,system_time const& target_time); bool timed_lock(boost::system_time const& target_time); #endif };
Like boost::unique_lock, boost::shared_lock models the Lockable concept, but rather than
acquiring unique ownership of the supplied Lockable object, locking an instance
of boost::shared_lock acquires shared ownership.
Like boost::unique_lock, not only does it
provide for RAII-style locking, it also allows for deferring acquiring
the lock until the lock()
member function is called explicitly, or trying to acquire the lock in
a non-blocking fashion, or with a timeout. Consequently, unlock()
is only called in the destructor if the lock object has locked the Lockable object, or otherwise
adopted a lock on the Lockable object.
An instance of boost::shared_lock is said to own
the lock state of a Lockable m
if mutex()
returns a pointer to m
and owns_lock()
returns true. If an object
that owns the lock state of a Lockable object is destroyed,
then the destructor will invoke mutex()->unlock_shared().
The member functions of boost::shared_lock are not thread-safe.
In particular, boost::shared_lock is intended to model
the shared ownership of a Lockable object by a particular
thread, and the member functions that release ownership of the lock state
(including the destructor) must be called by the same thread that acquired
ownership of the lock state.
Creates a lock object with no associated mutex.
owns_lock()
returns false. mutex()
returns NULL.
Nothing.
Stores a reference to m.
Invokes m.lock_shared().
owns_lock()
returns true. mutex()
returns &m.
Any exception thrown by the call to m.lock_shared().
The current thread owns an exclusive lock on m.
Stores a reference to m.
Takes ownership of the lock state of m.
owns_lock()
returns true. mutex()
returns &m.
Nothing.
Stores a reference to m.
owns_lock()
returns false. mutex()
returns &m.
Nothing.
Stores a reference to m.
Invokes m.try_lock_shared(),
and takes ownership of the lock state if the call returns true.
mutex()
returns &m.
If the call to try_lock_shared()
returned true, then
owns_lock()
returns true, otherwise
owns_lock()
returns false.
Nothing.
Stores a reference to m.
Invokes m.timed_lock(abs_time),
and takes ownership of the lock state if the call returns true.
mutex()
returns &m.
If the call to timed_lock_shared()
returned true, then
owns_lock()
returns true, otherwise
owns_lock()
returns false.
Any exceptions thrown by the call to m.timed_lock(abs_time).
Invokes mutex()-> unlock_shared()
if owns_lock()
returns true.
Nothing.
true if the *this
owns the lock on the Lockable object associated
with *this.
Nothing.
A pointer to the Lockable object associated
with *this,
or NULL if there
is no such object.
Nothing.
Nothing.
The association between *this and the Lockable object is removed,
without affecting the lock state of the Lockable object. If owns_lock()
would have returned true,
it is the responsibility of the calling code to ensure that the
Lockable is correctly
unlocked.
A pointer to the Lockable object associated
with *this
at the point of the call, or NULL
if there is no such object.
Nothing.
*this
is no longer associated with any Lockable object. mutex()
returns NULL and
owns_lock()
returns false.
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template<typename Lockable> class upgrade_lock { public: typedef Lockable mutex_type; // Upgrade locking upgrade_lock(); explicit upgrade_lock(mutex_type& m_); upgrade_lock(mutex_type& m, defer_lock_t) noexcept; upgrade_lock(mutex_type& m, try_to_lock_t); upgrade_lock(mutex_type& m, adopt_lock_t); template <class Clock, class Duration> upgrade_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> upgrade_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); ~upgrade_lock(); upgrade_lock(const upgrade_lock& other) = delete; upgrade_lock& operator=(const upgrade_lock<Lockable> & other) = delete; upgrade_lock(upgrade_lock<Lockable> && other); upgrade_lock& operator=(upgrade_lock<Lockable> && other); void lock(); bool try_lock(); template <class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock(); #ifdef BOOST_THREAD_PROVIDES_SHARED_MUTEX_UPWARDS_CONVERSION // Conversion from shared locking upgrade_lock(shared_lock<mutex_type>&& sl, try_to_lock_t); template <class Clock, class Duration> upgrade_lock(shared_lock<mutex_type>&& sl, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> upgrade_lock(shared_lock<mutex_type>&& sl, const chrono::duration<Rep, Period>& rel_time); #endif // Conversion from exclusive locking explicit upgrade_lock(unique_lock<Lockable> && other); // Setters void swap(upgrade_lock& other); mutex_type* release() noexcept; // Getters explicit operator bool() const; bool owns_lock() const; mutex_type mutex() const; };
Like boost::unique_lock, boost::upgrade_lock models the Lockable concept, but rather than
acquiring unique ownership of the supplied Lockable object, locking an instance
of boost::upgrade_lock acquires upgrade
ownership.
Like boost::unique_lock, not only does it
provide for RAII-style locking, it also allows for deferring acquiring
the lock until the lock()
member function is called explicitly, or trying to acquire the lock in
a non-blocking fashion, or with a timeout. Consequently, unlock()
is only called in the destructor if the lock object has locked the Lockable object, or otherwise
adopted a lock on the Lockable object.
An instance of boost::upgrade_lock is said to own
the lock state of a Lockable m
if mutex()
returns a pointer to m
and owns_lock()
returns true. If an object
that owns the lock state of a Lockable object is destroyed,
then the destructor will invoke mutex()->unlock_upgrade().
The member functions of boost::upgrade_lock are not thread-safe.
In particular, boost::upgrade_lock is intended to model
the upgrade ownership of a UpgradeLockable object by a particular
thread, and the member functions that release ownership of the lock state
(including the destructor) must be called by the same thread that acquired
ownership of the lock state.
// #include <boost/thread/locks.hpp> // #include <boost/thread/lock_types.hpp> template <class Lockable> class upgrade_to_unique_lock { public: typedef Lockable mutex_type; explicit upgrade_to_unique_lock(upgrade_lock<Lockable>& m_); ~upgrade_to_unique_lock(); upgrade_to_unique_lock(upgrade_to_unique_lock const& other) = delete; upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Lockable> const& other) = delete; upgrade_to_unique_lock(upgrade_to_unique_lock<Lockable> && other); upgrade_to_unique_lock& operator=(upgrade_to_unique_lock<Lockable> && other); void swap(upgrade_to_unique_lock& other); explicit operator bool() const; bool owns_lock() const; mutex_type* mutex() const; };
boost::upgrade_to_unique_lock allows
for a temporary upgrade of an boost::upgrade_lock to exclusive ownership.
When constructed with a reference to an instance of boost::upgrade_lock, if that instance
has upgrade ownership on some Lockable object, that ownership
is upgraded to exclusive ownership. When the boost::upgrade_to_unique_lock instance
is destroyed, the ownership of the Lockable is downgraded back to
upgrade ownership.
class MutexType::scoped_try_lock { private: MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>& other); MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>& other); public: MutexType::scoped_try_lock(); explicit MutexType::scoped_try_lock(MutexType& m); MutexType::scoped_try_lock(MutexType& m_,adopt_lock_t); MutexType::scoped_try_lock(MutexType& m_,defer_lock_t); MutexType::scoped_try_lock(MutexType& m_,try_to_lock_t); MutexType::scoped_try_lock(MutexType::scoped_try_lock<MutexType>&& other); MutexType::scoped_try_lock& operator=(MutexType::scoped_try_lock<MutexType>&& other); void swap(MutexType::scoped_try_lock&& other); void lock(); bool try_lock(); void unlock(); MutexType* mutex() const; MutexType* release(); explicit operator bool() const; bool owns_lock() const; };
The member typedef scoped_try_lock
is provided for each distinct MutexType
as a typedef to a class with the preceding definition. The semantics of
each constructor and member function are identical to those of boost::unique_lock<MutexType>
for the same MutexType,
except that the constructor that takes a single reference to a mutex will
call m.try_lock() rather than m.lock().