|  | Home | Libraries | People | FAQ | More | 
mutex
#include <boost/fiber/mutex.hpp> 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().
      
lock()
void lock();
The calling fiber doesn't own the mutex.
The current fiber blocks until ownership can be obtained.
              lock_error
            
              resource_deadlock_would_occur: if
              boost::this_fiber::get_id()
              already owns the mutex.
            
try_lock()
bool try_lock();
The calling fiber doesn't own the mutex.
Attempt to obtain ownership for the current fiber without blocking.
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
              lock_error
            
              resource_deadlock_would_occur: if
              boost::this_fiber::get_id()
              already owns the mutex.
            
unlock()
void unlock();
              The current fiber owns *this.
            
              Releases a lock on *this
              by the current fiber.
            
              lock_error
            
              operation_not_permitted: if boost::this_fiber::get_id()
              does not own the mutex.
            
timed_mutex
#include <boost/fiber/timed_mutex.hpp> 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.
      
lock()
void lock();
The calling fiber doesn't own the mutex.
The current fiber blocks until ownership can be obtained.
              lock_error
            
              resource_deadlock_would_occur: if
              boost::this_fiber::get_id()
              already owns the mutex.
            
try_lock()
bool try_lock();
The calling fiber doesn't own the mutex.
Attempt to obtain ownership for the current fiber without blocking.
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
              lock_error
            
              resource_deadlock_would_occur: if
              boost::this_fiber::get_id()
              already owns the mutex.
            
unlock()
void unlock();
              The current fiber owns *this.
            
              Releases a lock on *this
              by the current fiber.
            
              lock_error
            
              operation_not_permitted: if boost::this_fiber::get_id()
              does not own the mutex.
            
try_lock_until()
template< typename Clock, typename Duration > bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);
The calling fiber doesn't own the mutex.
              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 timed_mutex::try_lock().
            
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
              lock_error, timeout-related
              exceptions.
            
              resource_deadlock_would_occur: if
              boost::this_fiber::get_id()
              already owns the mutex.
            
try_lock_for()
template< typename Rep, typename Period > bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);
The calling fiber doesn't own the mutex.
              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 timed_mutex::try_lock().
            
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
              lock_error, timeout-related
              exceptions.
            
              resource_deadlock_would_occur: if
              boost::this_fiber::get_id()
              already owns the mutex.
            
recursive_mutex
#include <boost/fiber/recursive_mutex.hpp> 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.
      
lock()
void lock();
The current fiber blocks until ownership can be obtained.
Nothing
try_lock()
bool try_lock() noexcept;
Attempt to obtain ownership for the current fiber without blocking.
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
Nothing.
unlock()
void unlock();
              Releases a lock on *this
              by the current fiber.
            
              lock_error
            
              operation_not_permitted: if boost::this_fiber::get_id()
              does not own the mutex.
            
recursive_timed_mutex
#include <boost/fiber/recursive_timed_mutex.hpp> 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.
      
lock()
void lock();
The current fiber blocks until ownership can be obtained.
Nothing
try_lock()
bool try_lock() noexcept;
Attempt to obtain ownership for the current fiber without blocking.
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
Nothing.
unlock()
void unlock();
              Releases a lock on *this
              by the current fiber.
            
              lock_error
            
              operation_not_permitted: if boost::this_fiber::get_id()
              does not own the mutex.
            
try_lock_until()
template< typename Clock, typename Duration > bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);
              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 recursive_timed_mutex::try_lock().
            
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
Timeout-related exceptions.
try_lock_for()
template< typename Rep, typename Period > bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);
              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 recursive_timed_mutex::try_lock().
            
              true if ownership was
              obtained for the current fiber, false
              otherwise.
            
Timeout-related exceptions.