Difference between revisions of "cpp/header/shared mutex"
From cppreference.com
(+) |
m (move) |
||
| Line 4: | Line 4: | ||
{{dsc begin}} | {{dsc begin}} | ||
{{dsc h1|Classes}} | {{dsc h1|Classes}} | ||
| − | {{dsc inc | cpp/thread/dsc | + | {{dsc inc | cpp/thread/dsc shared_timed_mutex}} |
{{dsc inc | cpp/thread/dsc shared_lock}} | {{dsc inc | cpp/thread/dsc shared_lock}} | ||
{{dsc h1|Functions}} | {{dsc h1|Functions}} | ||
| Line 14: | Line 14: | ||
{{source|1= | {{source|1= | ||
namespace std { | namespace std { | ||
| − | class | + | class shared_timed_mutex; |
template <class Mutex> class shared_lock; | template <class Mutex> class shared_lock; | ||
| Line 23: | Line 23: | ||
}} | }} | ||
| − | ====Class {{lc|std:: | + | ====Class {{lc|std::shared_timed_mutex}}==== |
{{source|1= | {{source|1= | ||
| − | class | + | class shared_timed_mutex { |
public: | public: | ||
| − | + | shared_timed_mutex(); | |
| − | ~ | + | ~shared_timed_mutex(); |
| − | + | shared_timed_mutex(const shared_timed_mutex&) = delete; | |
| − | + | shared_timed_mutex& operator=(const shared_timed_mutex&) = delete; | |
// Exclusive ownership | // Exclusive ownership | ||
Revision as of 14:36, 22 March 2014
This header is part of the thread support library.
Classes | ||
| (C++14) |
provides shared mutual exclusion facility and implements locking with a timeout (class) | |
| (C++14) |
implements movable shared mutex ownership wrapper (class template) | |
Functions | ||
| (C++14) |
specializes the std::swap algorithm (function template) | |
Synopsis
namespace std { class shared_timed_mutex; template <class Mutex> class shared_lock; template <class Mutex> void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept; }
class shared_timed_mutex { public: shared_timed_mutex(); ~shared_timed_mutex(); shared_timed_mutex(const shared_timed_mutex&) = delete; shared_timed_mutex& operator=(const shared_timed_mutex&) = delete; // Exclusive ownership void lock(); // blocking 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(); // Shared ownership void lock_shared(); // blocking bool try_lock_shared(); template <class Rep, class Period> bool try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time); template <class Clock, class Duration> bool try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time); void unlock_shared(); };
template <class Mutex> class shared_lock { public: typedef Mutex mutex_type; shared_lock() noexcept; explicit shared_lock(mutex_type& m); // blocking shared_lock(mutex_type& m, defer_lock_t) noexcept; shared_lock(mutex_type& m, try_to_lock_t); shared_lock(mutex_type& m, adopt_lock_t); template <class Clock, class Duration> shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time); template <class Rep, class Period> shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time); ~shared_lock(); shared_lock(shared_lock const&) = delete; shared_lock& operator=(shared_lock const&) = delete; shared_lock(shared_lock&& u) noexcept; shared_lock& operator=(shared_lock&& u) noexcept; void lock(); // blocking 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(); // Setters void swap(shared_lock& u) noexcept; mutex_type* release() noexcept; // Getters bool owns_lock() const noexcept; explicit operator bool () const noexcept; mutex_type* mutex() const noexcept; private: mutex_type* pm; // exposition only bool owns; // exposition only };
