C++并发编程 - 互斥锁（lock_guard和unqiue_lock）

template<class _Mutex>
class lock_guard    
{   
public:
    using mutex_type = _Mutex;

    // construct and lock
    explicit lock_guard(_Mutex& _Mtx)
        : _MyMutex(_Mtx)
    {
        _MyMutex.lock();
    }

    // construct but don't lock
    lock_guard(_Mutex& _Mtx, adopt_lock_t)
        : _MyMutex(_Mtx)
    {   
    }

    // destructor and unlocks
    ~lock_guard() noexcept
    {
        _MyMutex.unlock();
    }

    lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;

private:
    _Mutex& _MyMutex;
};

template<class _Mutex>
class unique_lock
{ // whizzy class with destructor that unlocks mutex
public:
 typedef unique_lock<_Mutex> _Myt;
 typedef _Mutex mutex_type;
 
 // CONSTRUCT, ASSIGN, AND DESTROY
 unique_lock() _NOEXCEPT
  : _Pmtx(0), _Owns(false)
 { // default construct
 }
 
 explicit unique_lock(_Mutex& _Mtx)
  : _Pmtx(&_Mtx), _Owns(false)
 { // construct and lock
  _Pmtx->lock();
  _Owns = true;
 }
 
 unique_lock(_Mutex& _Mtx, adopt_lock_t)
  : _Pmtx(&_Mtx), _Owns(true)
 { // construct and assume already locked
 }
 
 unique_lock(_Mutex& _Mtx, defer_lock_t) _NOEXCEPT
  : _Pmtx(&_Mtx), _Owns(false)
 { // construct but don't lock
 }
 
 unique_lock(_Mutex& _Mtx, try_to_lock_t)
  : _Pmtx(&_Mtx), _Owns(_Pmtx->try_lock())
 { // construct and try to lock
 }
 
 template<class _Rep,
  class _Period>
  unique_lock(_Mutex& _Mtx,
   const chrono::duration<_Rep, _Period>& _Rel_time)
  : _Pmtx(&_Mtx), _Owns(_Pmtx->try_lock_for(_Rel_time))
 { // construct and lock with timeout
 }
 
 template<class _Clock,
  class _Duration>
  unique_lock(_Mutex& _Mtx,
   const chrono::time_point<_Clock, _Duration>& _Abs_time)
  : _Pmtx(&_Mtx), _Owns(_Pmtx->try_lock_until(_Abs_time))
 { // construct and lock with timeout
 }
 
 unique_lock(_Mutex& _Mtx, const xtime *_Abs_time)
  : _Pmtx(&_Mtx), _Owns(false)
 { // try to lock until _Abs_time
  _Owns = _Pmtx->try_lock_until(_Abs_time);
 }
 
 unique_lock(unique_lock&& _Other) _NOEXCEPT
  : _Pmtx(_Other._Pmtx), _Owns(_Other._Owns)
 { // destructive copy
  _Other._Pmtx = 0;
  _Other._Owns = false;
 }
 
 unique_lock& operator=(unique_lock&& _Other)
 { // destructive copy
  if (this != &_Other)
  { // different, move contents
   if (_Owns)
    _Pmtx->unlock();
   _Pmtx = _Other._Pmtx;
   _Owns = _Other._Owns;
   _Other._Pmtx = 0;
   _Other._Owns = false;
  }
  return (*this);
 }
 
 ~unique_lock() _NOEXCEPT
 { // clean up
  if (_Owns)
   _Pmtx->unlock();
 }
 
 unique_lock(const unique_lock&) = delete;
 unique_lock& operator=(const unique_lock&) = delete;
 
 // LOCK AND UNLOCK
 void lock()
 { // lock the mutex
  _Validate();
  _Pmtx->lock();
  _Owns = true;
 }
 
 bool try_lock()
 { // try to lock the mutex
  _Validate();
  _Owns = _Pmtx->try_lock();
  return (_Owns);
 }
 
 template<class _Rep,
  class _Period>
  bool try_lock_for(const chrono::duration<_Rep, _Period>& _Rel_time)
 { // try to lock mutex for _Rel_time
  _Validate();
  _Owns = _Pmtx->try_lock_for(_Rel_time);
  return (_Owns);
 }
 
 template<class _Clock,
  class _Duration>
  bool try_lock_until(
   const chrono::time_point<_Clock, _Duration>& _Abs_time)
 { // try to lock mutex until _Abs_time
  _Validate();
  _Owns = _Pmtx->try_lock_until(_Abs_time);
  return (_Owns);
 }
 
 bool try_lock_until(const xtime *_Abs_time)
 { // try to lock the mutex until _Abs_time
  _Validate();
  _Owns = _Pmtx->try_lock_until(_Abs_time);
  return (_Owns);
 }
 
 void unlock()
 { // try to unlock the mutex
  if (!_Pmtx || !_Owns)
   _THROW_NCEE(system_error,
    _STD make_error_code(errc::operation_not_permitted));
 
  _Pmtx->unlock();
  _Owns = false;
 }
 
 // MUTATE
 void swap(unique_lock& _Other) _NOEXCEPT
 { // swap with _Other
  _STD swap(_Pmtx, _Other._Pmtx);
  _STD swap(_Owns, _Other._Owns);
 }
 
 _Mutex *release() _NOEXCEPT
 { // disconnect
  _Mutex *_Res = _Pmtx;
  _Pmtx = 0;
  _Owns = false;
  return (_Res);
 }
 
 // OBSERVE
 bool owns_lock() const _NOEXCEPT
 { // return true if this object owns the lock
  return (_Owns);
 }
 
 explicit operator bool() const _NOEXCEPT
 { // return true if this object owns the lock
  return (_Owns);
 }
 
 _Mutex *mutex() const _NOEXCEPT
 { // return pointer to managed mutex
  return (_Pmtx);
 }
 
private:
 _Mutex *_Pmtx;
 bool _Owns;
 
 void _Validate() const
 { // check if the mutex can be locked
  if (!_Pmtx)
   _THROW_NCEE(system_error,
    _STD make_error_code(errc::operation_not_permitted));
 
  if (_Owns)
   _THROW_NCEE(system_error,
    _STD make_error_code(errc::resource_deadlock_would_occur));
 }
};
 
// SWAP
template<class _Mutex>
 void swap(unique_lock<_Mutex>& _Left,
  unique_lock<_Mutex>& _Right) _NOEXCEPT
{ // swap _Left and _Right
 _Left.swap(_Right);
}