[/ (C) Copyright 2007-8 Anthony Williams. (C) Copyright 2013 Oliver Kowalke. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt). ] [section:mutex_types Mutex Types] [class_heading mutex] #include namespace boost { namespace fibers { class mutex { public: mutex(); ~mutex(); mutex( mutex const& other) = delete; mutex & operator=( mutex const& other) = delete; void lock(); bool try_lock(); void unlock(); }; }} __mutex__ provides an exclusive-ownership mutex. At most one fiber can own the lock on a given instance of __mutex__ at any time. Multiple concurrent calls to __lock__, __try_lock__ and __unlock__ shall be permitted. Any fiber blocked in __lock__ is suspended until the owning fiber releases the lock by calling __unlock__. [member_heading mutex..lock] void lock(); [variablelist [[Precondition:] [The calling fiber doesn't own the mutex.]] [[Effects:] [The current fiber blocks until ownership can be obtained.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]] ] [member_heading mutex..try_lock] bool try_lock(); [variablelist [[Precondition:] [The calling fiber doesn't own the mutex.]] [[Effects:] [Attempt to obtain ownership for the current fiber without blocking.]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]] ] [member_heading mutex..unlock] void unlock(); [variablelist [[Precondition:] [The current fiber owns `*this`.]] [[Effects:] [Releases a lock on `*this` by the current fiber.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]] ] [class_heading timed_mutex] #include namespace boost { namespace fibers { class timed_mutex { public: timed_mutex(); ~timed_mutex(); timed_mutex( timed_mutex const& other) = delete; timed_mutex & operator=( timed_mutex const& other) = delete; void lock(); bool try_lock(); void unlock(); template< typename Clock, typename Duration > bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time); template< typename Rep, typename Period > bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration); }; }} __timed_mutex__ provides an exclusive-ownership mutex. At most one fiber can own the lock on a given instance of __timed_mutex__ at any time. Multiple concurrent calls to __lock__, __try_lock__, __try_lock_until__, __try_lock_for__ and __unlock__ shall be permitted. [member_heading timed_mutex..lock] void lock(); [variablelist [[Precondition:] [The calling fiber doesn't own the mutex.]] [[Effects:] [The current fiber blocks until ownership can be obtained.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]] ] [member_heading timed_mutex..try_lock] bool try_lock(); [variablelist [[Precondition:] [The calling fiber doesn't own the mutex.]] [[Effects:] [Attempt to obtain ownership for the current fiber without blocking.]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]] ] [member_heading timed_mutex..unlock] void unlock(); [variablelist [[Precondition:] [The current fiber owns `*this`.]] [[Effects:] [Releases a lock on `*this` by the current fiber.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]] ] [template_member_heading timed_mutex..try_lock_until] template< typename Clock, typename Duration > bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time); [variablelist [[Precondition:] [The calling fiber doesn't own the mutex.]] [[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until ownership can be obtained, or the specified time is reached. If the specified time has already passed, behaves as [member_link timed_mutex..try_lock].]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [`lock_error`, timeout-related exceptions.]] [[Error Conditions:] [ [*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]] ] [template_member_heading timed_mutex..try_lock_for] template< typename Rep, typename Period > bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration); [variablelist [[Precondition:] [The calling fiber doesn't own the mutex.]] [[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until ownership can be obtained, or the specified time is reached. If the specified time has already passed, behaves as [member_link timed_mutex..try_lock].]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [`lock_error`, timeout-related exceptions.]] [[Error Conditions:] [ [*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]] ] [class_heading recursive_mutex] #include namespace boost { namespace fibers { class recursive_mutex { public: recursive_mutex(); ~recursive_mutex(); recursive_mutex( recursive_mutex const& other) = delete; recursive_mutex & operator=( recursive_mutex const& other) = delete; void lock(); bool try_lock() noexcept; void unlock(); }; }} __recursive_mutex__ provides an exclusive-ownership recursive mutex. At most one fiber can own the lock on a given instance of __recursive_mutex__ at any time. Multiple concurrent calls to __lock__, __try_lock__ and __unlock__ shall be permitted. A fiber that already has exclusive ownership of a given __recursive_mutex__ instance can call __lock__ or __try_lock__ to acquire an additional level of ownership of the mutex. __unlock__ must be called once for each level of ownership acquired by a single fiber before ownership can be acquired by another fiber. [member_heading recursive_mutex..lock] void lock(); [variablelist [[Effects:] [The current fiber blocks until ownership can be obtained.]] [[Throws:] [Nothing]] ] [member_heading recursive_mutex..try_lock] bool try_lock() noexcept; [variablelist [[Effects:] [Attempt to obtain ownership for the current fiber without blocking.]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [Nothing.]] ] [member_heading recursive_mutex..unlock] void unlock(); [variablelist [[Effects:] [Releases a lock on `*this` by the current fiber.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]] ] [class_heading recursive_timed_mutex] #include namespace boost { namespace fibers { class recursive_timed_mutex { public: recursive_timed_mutex(); ~recursive_timed_mutex(); recursive_timed_mutex( recursive_timed_mutex const& other) = delete; recursive_timed_mutex & operator=( recursive_timed_mutex const& other) = delete; void lock(); bool try_lock() noexcept; void unlock(); template< typename Clock, typename Duration > bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time); template< typename Rep, typename Period > bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration); }; }} __recursive_timed_mutex__ provides an exclusive-ownership recursive mutex. At most one fiber can own the lock on a given instance of __recursive_timed_mutex__ at any time. Multiple concurrent calls to __lock__, __try_lock__, __try_lock_for__, __try_lock_until__ and __unlock__ shall be permitted. A fiber that already has exclusive ownership of a given __recursive_timed_mutex__ instance can call __lock__, __try_lock__, __try_lock_for__ or __try_lock_until__ to acquire an additional level of ownership of the mutex. __unlock__ must be called once for each level of ownership acquired by a single fiber before ownership can be acquired by another fiber. [member_heading recursive_timed_mutex..lock] void lock(); [variablelist [[Effects:] [The current fiber blocks until ownership can be obtained.]] [[Throws:] [Nothing]] ] [member_heading recursive_timed_mutex..try_lock] bool try_lock() noexcept; [variablelist [[Effects:] [Attempt to obtain ownership for the current fiber without blocking.]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [Nothing.]] ] [member_heading recursive_timed_mutex..unlock] void unlock(); [variablelist [[Effects:] [Releases a lock on `*this` by the current fiber.]] [[Throws:] [`lock_error`]] [[Error Conditions:] [ [*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]] ] [template_member_heading recursive_timed_mutex..try_lock_until] template< typename Clock, typename Duration > bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time); [variablelist [[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until ownership can be obtained, or the specified time is reached. If the specified time has already passed, behaves as [member_link recursive_timed_mutex..try_lock].]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [Timeout-related exceptions.]] ] [template_member_heading recursive_timed_mutex..try_lock_for] template< typename Rep, typename Period > bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration); [variablelist [[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until ownership can be obtained, or the specified time is reached. If the specified time has already passed, behaves as [member_link recursive_timed_mutex..try_lock].]] [[Returns:] [`true` if ownership was obtained for the current fiber, `false` otherwise.]] [[Throws:] [Timeout-related exceptions.]] ] [endsect]