recursive_timed_mutex Class Reference

Public Member Functions
	recursive_timed_mutex () _NOEXCEPT
	recursive_timed_mutex (const recursive_timed_mutex &)=delete
recursive_timed_mutex &	operator= (const recursive_timed_mutex &)=delete
void	lock ()
bool	try_lock () _NOEXCEPT
void	unlock ()
template<class _Rep , class _Period >
bool	try_lock_for (const chrono::duration< _Rep, _Period > &_Rel_time)
template<class _Time >
bool	_Try_lock_until (_Time _Abs_time)
template<class _Clock , class _Duration >
bool	try_lock_until (const chrono::time_point< _Clock, _Duration > &_Abs_time)
bool	try_lock_until (const xtime *_Abs_time)

Private Attributes
mutex	_My_mutex
condition_variable	_My_cond
unsigned int	_My_locked
thread::id	_My_owner

Constructor & Destructor Documentation

recursive_timed_mutex::recursive_timed_mutex ( )

inline

        : _My_locked(0)
        {   // default construct
        }

recursive_timed_mutex::recursive_timed_mutex ( const recursive_timed_mutex &  )

delete

Member Function Documentation

template<class _Time >

bool recursive_timed_mutex::_Try_lock_until ( _Time  _Abs_time )

inline

        {   // try to lock the mutex with timeout
        thread::id _Tid = this_thread::get_id();

        unique_lock<mutex> _Lock(_My_mutex);

        if (_Tid == _My_owner)
            {
            if (_My_locked < UINT_MAX)
                ++_My_locked;
            else
                return (false);
            }
        else
            {
            if (!_My_cond.wait_until(_Lock, _Abs_time,
                [this] { return (_My_locked == 0); }))
                    return (false);
            _My_locked = 1;
            _My_owner = _Tid;
            }
        return (true);
        }

void recursive_timed_mutex::lock ( )

inline

        {   // lock the mutex
        thread::id _Tid = this_thread::get_id();

        unique_lock<mutex> _Lock(_My_mutex);

        if (_Tid == _My_owner)
            {
            if (_My_locked < UINT_MAX)
                ++_My_locked;
            else
                _THROW_NCEE(system_error,
                    _STD make_error_code(errc::device_or_resource_busy));
            }
        else
            {
            while (_My_locked != 0)
                _My_cond.wait(_Lock);
            _My_locked = 1;
            _My_owner = _Tid;
            }
        }

recursive_timed_mutex& recursive_timed_mutex::operator= ( const recursive_timed_mutex &  )

delete

bool recursive_timed_mutex::try_lock ( )

inline

        {   // try to lock the mutex
        thread::id _Tid = this_thread::get_id();

        lock_guard<mutex> _Lock(_My_mutex);

        if (_Tid == _My_owner)
            {
            if (_My_locked < UINT_MAX)
                ++_My_locked;
            else
                return (false);
            }
        else
            {
            if (_My_locked != 0)
                return (false);
            else
                {
                _My_locked = 1;
                _My_owner = _Tid;
                }
            }
        return (true);
    }

template<class _Rep , class _Period >

bool recursive_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));
        }

template<class _Clock , class _Duration >

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

inline

        {   // try to lock the mutex with timeout
        return (_Try_lock_until(_Abs_time));
        }

bool recursive_timed_mutex::try_lock_until ( const xtime *  _Abs_time )

inline

        {   // try to lock the mutex with timeout
        return (_Try_lock_until(_Abs_time));
        }

void recursive_timed_mutex::unlock ( )

inline

        {   // unlock the mutex
        bool _Do_notify = false;

            {
            lock_guard<mutex> _Lock(_My_mutex);
            --_My_locked;
            if (_My_locked == 0)
                {
                _Do_notify = true;
                _My_owner = thread::id();
                }
            }

        if (_Do_notify)
            _My_cond.notify_one();
        }

Member Data Documentation

condition_variable recursive_timed_mutex::_My_cond

private

unsigned int recursive_timed_mutex::_My_locked

private

mutex recursive_timed_mutex::_My_mutex

private

thread::id recursive_timed_mutex::_My_owner

private

---

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

• VS2015/inc/mutex