33 Thread support library [thread]
shared_lock() noexcept;
Effects: Constructs an object of type
shared_lock. Postconditions: pm == nullptr and
owns == false. explicit shared_lock(mutex_type& m);
Requires: The calling thread does not own the mutex for any ownership mode
. Effects: Constructs an object of type
shared_lock and calls
m.lock_shared(). Postconditions: pm == addressof(m) and
owns == true. shared_lock(mutex_type& m, defer_lock_t) noexcept;
Effects: Constructs an object of type
shared_lock. Postconditions: pm == addressof(m) and
owns == false. shared_lock(mutex_type& m, try_to_lock_t);
Requires: The calling thread does not own the mutex for any ownership mode
. Effects: Constructs an object of type
shared_lock and calls
m.try_lock_shared(). Postconditions: pm == addressof(m) and
owns == res
where
res is the
value returned by the call to
m.try_lock_shared(). shared_lock(mutex_type& m, adopt_lock_t);
Requires: The calling thread has shared ownership of the mutex
. Effects: Constructs an object of type
shared_lock. Postconditions: pm == addressof(m) and
owns == true. template <class Clock, class Duration>
shared_lock(mutex_type& m,
const chrono::time_point<Clock, Duration>& abs_time);
Requires: The calling thread does not own the mutex for any ownership mode
. Effects: Constructs an object of type
shared_lock and calls
m.try_lock_shared_until(abs_time). Postconditions: pm == addressof(m) and
owns == res
where
res
is the value returned by the call to
m.try_lock_shared_until(abs_time). template <class Rep, class Period>
shared_lock(mutex_type& m,
const chrono::duration<Rep, Period>& rel_time);
Requires: The calling thread does not own the mutex for any ownership mode
. Effects: Constructs an object of type
shared_lock and calls
m.try_lock_shared_for(rel_time). Postconditions: pm == addressof(m) and
owns == res
where
res is
the value returned by the call to
m.try_lock_shared_for(rel_time). ~shared_lock();
Effects: If
owns calls
pm->unlock_shared(). shared_lock(shared_lock&& sl) noexcept;
Postconditions: pm == sl_p.pm and
owns == sl_p.owns (where
sl_p is the state of
sl just prior to this construction),
sl.pm == nullptr and
sl.owns == false. shared_lock& operator=(shared_lock&& sl) noexcept;
Effects: If
owns calls
pm->unlock_shared(). Postconditions: pm == sl_p.pm and
owns == sl_p.owns (where
sl_p is the state of
sl just prior to this assignment),
sl.pm == nullptr and
sl.owns == false.