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.

Любое волокно, заблокированное в lock(), приостанавливается до тех пор, пока владеющее волокном не освободит замок, позвонив unlock().

Member function lock()

void lock();

Member function try_lock()

bool try_lock();

Member function unlock()

void unlock();

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();

Member function try_lock()

bool try_lock();

Member function unlock()

void unlock();

Templated member function try_lock_until()

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

Templated member function try_lock_for()

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

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();

Member function try_lock()

bool try_lock() noexcept;

Member function unlock()

void unlock();

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();

Member function try_lock()

bool try_lock() noexcept;

Member function unlock()

void unlock();

Templated member function try_lock_until()

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

Templated member function try_lock_for()

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