Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for a snapshot of the develop branch, built from commit 3bdf7dba54.
PrevUpHomeNext

Mutex Types

Class 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().

Member function lock()

void lock();

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 function try_lock()

bool try_lock();

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 function unlock()

void unlock();

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 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.

Member function lock()

void lock();

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 function try_lock()

bool try_lock();

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 function unlock()

void unlock();

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.

Templated member function try_lock_until()

template< typename Clock, typename Duration >
bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);

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 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.

Templated member function try_lock_for()

template< typename Rep, typename Period >
bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);

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 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 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.

Member function lock()

void lock();

Effects:

The current fiber blocks until ownership can be obtained.

Throws:

Nothing

Member function try_lock()

bool try_lock() noexcept;

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 function unlock()

void unlock();

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 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.

Member function lock()

void lock();

Effects:

The current fiber blocks until ownership can be obtained.

Throws:

Nothing

Member function try_lock()

bool try_lock() noexcept;

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 function unlock()

void unlock();

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.

Templated member function try_lock_until()

template< typename Clock, typename Duration >
bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);

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 recursive_timed_mutex::try_lock().

Returns:

true if ownership was obtained for the current fiber, false otherwise.

Throws:

Timeout-related exceptions.

Templated member function try_lock_for()

template< typename Rep, typename Period >
bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);

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 recursive_timed_mutex::try_lock().

Returns:

true if ownership was obtained for the current fiber, false otherwise.

Throws:

Timeout-related exceptions.


PrevUpHomeNext