shared_timed_mutex Class Reference

Public Member Functions
	shared_timed_mutex () _NOEXCEPT
	~shared_timed_mutex () _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 ()
void	lock_shared ()
bool	try_lock_shared ()
template<class _Rep , class _Period >
bool	try_lock_shared_for (const chrono::duration< _Rep, _Period > &_Rel_time)
template<class _Time >
bool	_Try_lock_shared_until (_Time _Abs_time)
template<class _Clock , class _Duration >
bool	try_lock_shared_until (const chrono::time_point< _Clock, _Duration > &_Abs_time)
bool	try_lock_shared_until (const xtime *_Abs_time)
void	unlock_shared ()
	shared_timed_mutex (const shared_timed_mutex &)=delete
shared_timed_mutex &	operator= (const shared_timed_mutex &)=delete

Private Types
typedef unsigned int	_Read_cnt_t

Private Attributes
mutex	_Mymtx
condition_variable	_Read_queue
condition_variable	_Write_queue
_Read_cnt_t	_Readers
bool	_Writing

Static Private Attributes
static constexpr _Read_cnt_t	_Max_readers = _Read_cnt_t(-1)

Member Typedef Documentation

typedef unsigned int shared_timed_mutex::_Read_cnt_t

private

Constructor & Destructor Documentation

shared_timed_mutex::shared_timed_mutex ( )

inline

        : _Mymtx(), _Read_queue(), _Write_queue(),
            _Readers(0), _Writing(false)
        {   // default construct
        }

shared_timed_mutex::~shared_timed_mutex ( )

inline

        {   // destroy the object
        }

shared_timed_mutex::shared_timed_mutex ( const shared_timed_mutex &  )

delete

Member Function Documentation

template<class _Time >

bool shared_timed_mutex::_Try_lock_shared_until ( _Time  _Abs_time )

inline

        {   // try to lock non-exclusive until absolute time
        auto _Can_acquire = [this] {
            return (!_Writing && _Readers < _Max_readers); };

        unique_lock<mutex> _Lock(_Mymtx);

        if (!_Write_queue.wait_until(_Lock, _Abs_time, _Can_acquire))
            return (false);

        ++_Readers;
        return (true);
        }

void shared_timed_mutex::lock ( )

inline

        {   // lock exclusive
        unique_lock<mutex> _Lock(_Mymtx);
        while (_Writing)
            _Write_queue.wait(_Lock);
        _Writing = true;
        while (0 < _Readers)
            _Read_queue.wait(_Lock);    // wait for writing, no readers
        }

void shared_timed_mutex::lock_shared ( )

inline

        {   // lock non-exclusive
        unique_lock<mutex> _Lock(_Mymtx);
        while (_Writing || _Readers == _Max_readers)
            _Write_queue.wait(_Lock);
        ++_Readers;
        }

shared_timed_mutex& shared_timed_mutex::operator= ( const shared_timed_mutex &  )

delete

bool shared_timed_mutex::try_lock ( )

inline

        {   // try to lock exclusive
        lock_guard<mutex> _Lock(_Mymtx);
        if (_Writing || 0 < _Readers)
            return (false);
        else
            {   // set writing, no readers
            _Writing = true;
            return (true);
            }
        }

template<class _Rep , class _Period >

bool shared_timed_mutex::try_lock_for ( const chrono::duration< _Rep, _Period > &  _Rel_time )

inline

        {   // try to lock for duration
        return (try_lock_until(chrono::steady_clock::now() + _Rel_time));
        }

bool shared_timed_mutex::try_lock_shared ( )

inline

        {   // try to lock non-exclusive
        lock_guard<mutex> _Lock(_Mymtx);
        if (_Writing || _Readers == _Max_readers)
            return (false);
        else
            {   // count another reader
            ++_Readers;
            return (true);
            }
        }

template<class _Rep , class _Period >

bool shared_timed_mutex::try_lock_shared_for ( const chrono::duration< _Rep, _Period > &  _Rel_time )

inline

        {   // try to lock non-exclusive for relative time
        return (try_lock_shared_until(_Rel_time
            + chrono::steady_clock::now()));
        }

template<class _Clock , class _Duration >

bool shared_timed_mutex::try_lock_shared_until ( const chrono::time_point< _Clock, _Duration > &  _Abs_time )

inline

        {   // try to lock non-exclusive until absolute time
        return (_Try_lock_shared_until(_Abs_time));
        }

bool shared_timed_mutex::try_lock_shared_until ( const xtime *  _Abs_time )

inline

        {   // try to lock non-exclusive until absolute time
        return (_Try_lock_shared_until(_Abs_time));
        }

template<class _Clock , class _Duration >

bool shared_timed_mutex::try_lock_until ( const chrono::time_point< _Clock, _Duration > &  _Abs_time )

inline

        {   // try to lock until time point
        auto _Not_writing = [this] { return (!_Writing); };
        auto _Zero_readers = [this] { return (_Readers == 0); };
        unique_lock<mutex> _Lock(_Mymtx);

        if (!_Write_queue.wait_until(_Lock, _Abs_time, _Not_writing))
            return (false);

        _Writing = true;

        if (!_Read_queue.wait_until(_Lock, _Abs_time, _Zero_readers))
            {   // timeout, leave writing state
            _Writing = false;
            _Lock.unlock(); // unlock before notifying, for efficiency
            _Write_queue.notify_all();
            return (false);
            }

        return (true);
        }

void shared_timed_mutex::unlock ( )

inline

        {   // unlock exclusive
            {   // unlock before notifying, for efficiency
            lock_guard<mutex> _Lock(_Mymtx);

            _Writing = false;
            }

        _Write_queue.notify_all();
        }

void shared_timed_mutex::unlock_shared ( )

inline

        {   // unlock non-exclusive
        _Read_cnt_t _Local_readers;
        bool _Local_writing;

            {   // unlock before notifying, for efficiency
            lock_guard<mutex> _Lock(_Mymtx);
            --_Readers;
            _Local_readers = _Readers;
            _Local_writing = _Writing;
            }

        if (_Local_writing && _Local_readers == 0)
            _Read_queue.notify_one();
        else if (!_Local_writing && _Local_readers == _Max_readers - 1)
            _Write_queue.notify_all();
        }

Member Data Documentation

constexpr _Read_cnt_t shared_timed_mutex::_Max_readers = _Read_cnt_t(-1)

staticprivate

mutex shared_timed_mutex::_Mymtx

private

condition_variable shared_timed_mutex::_Read_queue

private

_Read_cnt_t shared_timed_mutex::_Readers

private

condition_variable shared_timed_mutex::_Write_queue

private

bool shared_timed_mutex::_Writing

private

---

The documentation for this class was generated from the following file:

• VS2017/inc/shared_mutex