[thread.lock.unique] (original) (raw)

32 Thread support library [thread]

32.5 Mutual exclusion [thread.mutex]

32.5.4 Locks [thread.lock]

32.5.4.3 Class template unique_­lock [thread.lock.unique]

namespace std { template class unique_lock { public: using mutex_type = Mutex;

unique_lock() noexcept;
explicit unique_lock(mutex_type& m);
unique_lock(mutex_type& m, defer_lock_t) noexcept;
unique_lock(mutex_type& m, try_to_lock_t);
unique_lock(mutex_type& m, adopt_lock_t);
template<class Clock, class Duration>
  unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
template<class Rep, class Period>
  unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
~unique_lock();

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

unique_lock(unique_lock&& u) noexcept;
unique_lock& operator=(unique_lock&& u);


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 swap(unique_lock& u) noexcept;
mutex_type* release() noexcept;


bool owns_lock() const noexcept;
explicit operator bool () const noexcept;
mutex_type* mutex() const noexcept;

private: mutex_type* pm;
bool owns;
};

template void swap(unique_lock& x, unique_lock& y) noexcept; }

An object of type unique_­lock controls the ownership of a lockable object within a scope.

Ownership of the lockable object may be acquired at construction or after construction, and may be transferred, after acquisition, to another unique_­lock object.

Objects of type unique_­lock are not copyable but are movable.

The behavior of a program is undefined if the contained pointerpm is not null and the lockable object pointed to by pm does not exist for the entire remaining lifetime ([basic.life]) of the unique_­lock object.

[ Note

:

unique_­lock<Mutex> meets the Cpp17BasicLockable requirements.

If Mutexmeets the Cpp17Lockable requirements ([thread.req.lockable.req]),unique_­lock<Mutex> also meets the Cpp17Lockable requirements; if Mutexmeets the Cpp17TimedLockable requirements ([thread.req.lockable.timed]),unique_­lock<Mutex> also meets the Cpp17TimedLockable requirements.

— end note

]

32.5.4.3.1 Constructors, destructor, and assignment [thread.lock.unique.cons]

Postconditions: pm == 0 and owns == false.

explicit unique_lock(mutex_type& m);

Preconditions:If mutex_­type is not a recursive mutex the calling thread does not own the mutex.

Postconditions: pm == addressof(m) and owns == true.

unique_lock(mutex_type& m, defer_lock_t) noexcept;

Postconditions: pm == addressof(m) and owns == false.

unique_lock(mutex_type& m, try_to_lock_t);

Preconditions:The supplied Mutex type meets the Cpp17Lockablerequirements ([thread.req.lockable.req]).

If mutex_­type is not a recursive mutex the calling thread does not own the mutex.

Effects:Calls m.try_­lock().

Postconditions: pm == addressof(m) and owns == res, where res is the value returned by the call to m.try_­lock().

unique_lock(mutex_type& m, adopt_lock_t);

Preconditions:The calling thread owns the mutex.

Postconditions: pm == addressof(m) and owns == true.

template<class Clock, class Duration> unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);

Preconditions:If mutex_­type is not a recursive mutex the calling thread does not own the mutex.

Effects:Calls m.try_­lock_­until(abs_­time).

Postconditions: pm == addressof(m) and owns == res, where res is the value returned by the call to m.try_­lock_­until(abs_­time).

template<class Rep, class Period> unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);

Preconditions:If mutex_­type is not a recursive mutex the calling thread does not own the mutex.

Effects:Calls m.try_­lock_­for(rel_­time).

Postconditions: pm == addressof(m) and owns == res, where res is the value returned by the call to m.try_­lock_­for(rel_­time).

unique_lock(unique_lock&& u) noexcept;

Postconditions: pm == u_­p.pm and owns == u_­p.owns (where u_­p is the state of u just prior to this construction), u.pm == 0 and u.owns == false.

unique_lock& operator=(unique_lock&& u);

Effects:If owns calls pm->unlock().

Postconditions: pm == u_­p.pm and owns == u_­p.owns (where u_­p is the state of u just prior to this construction), u.pm == 0 and u.owns == false.

[ Note

:

With a recursive mutex it is possible for both *this and u to own the same mutex before the assignment.

In this case, *this will own the mutex after the assignment and u will not.

— end note

]

Effects:If owns calls pm->unlock().

32.5.4.3.2 Locking [thread.lock.unique.locking]

Effects:As if by pm->lock().

Postconditions: owns == true.

Throws:Any exception thrown by pm->lock().

Error conditions:

• operation_­not_­permitted — if pm is nullptr.
• resource_­deadlock_­would_­occur — if on entry ownsis true.

Effects:As if by pm->try_­lock().

Returns:The value returned by the call to try_­lock().

Postconditions: owns == res, where res is the value returned by the call to try_­lock().

Throws:Any exception thrown by pm->try_­lock().

Error conditions:

• operation_­not_­permitted — if pm is nullptr.
• resource_­deadlock_­would_­occur — if on entry ownsis true.

template<class Clock, class Duration> bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);

Effects:As if by pm->try_­lock_­until(abs_­time).

Returns:The value returned by the call to try_­lock_­until(abs_­time).

Postconditions: owns == res, where res is the value returned by the call to try_­lock_­until(abs_­time).

Throws:Any exception thrown by pm->try_­lock_­until().

Error conditions:

• operation_­not_­permitted — if pm is nullptr.
• resource_­deadlock_­would_­occur — if on entry owns istrue.

template<class Rep, class Period> bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);

Effects:As if by pm->try_­lock_­for(rel_­time).

Returns:The value returned by the call to try_­lock_­for(rel_­time).

Postconditions: owns == res, where res is the value returned by the call to try_­lock_­for(rel_­time).

Throws:Any exception thrown by pm->try_­lock_­for().

Error conditions:

• operation_­not_­permitted — if pm is nullptr.
• resource_­deadlock_­would_­occur — if on entry owns istrue.

Effects:As if by pm->unlock().

Postconditions: owns == false.

Error conditions:

• operation_­not_­permitted — if on entry owns is false.

32.5.4.3.3 Modifiers [thread.lock.unique.mod]

void swap(unique_lock& u) noexcept;

Effects:Swaps the data members of *this and u.

mutex_type* release() noexcept;

Returns:The previous value of pm.

Postconditions: pm == 0 and owns == false.

template<class Mutex> void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;

Effects:As if by x.swap(y).

32.5.4.3.4 Observers [thread.lock.unique.obs]

bool owns_lock() const noexcept;

explicit operator bool() const noexcept;

mutex_type *mutex() const noexcept;