Difference between revisions of "cpp/thread/shared mutex"
From cppreference.com
(Cubbi moved page cpp/thread/shared mutex to cpp/thread/shared timed mutex: renamed in C++14) |
(+) |
||
| Line 1: | Line 1: | ||
| − | + | {{cpp/title|shared_mutex}} | |
| + | {{cpp/thread/shared_mutex/navbar}} | ||
| + | {{ddcl | header=shared_mutex | since=c++17 | 1= | ||
| + | class shared_mutex; | ||
| + | }} | ||
| + | |||
| + | The {{tt|shared_mutex}} class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. In contrast to other mutex types which facilitate exclusive access, a shared_mutex has two levels of access: | ||
| + | |||
| + | * ''shared'' - several threads can share ownership of the same mutex. | ||
| + | |||
| + | * ''exclusive'' - only one thread can own the mutex. | ||
| + | |||
| + | Shared mutexes are usually used in situations when multiple readers can access the same resource at the same time without causing data races, but only one writer can do so. | ||
| + | |||
| + | The {{tt|shared_mutex}} class satisfies all requirements of {{concept|SharedMutex}} and {{concept|StandardLayoutType}}. | ||
| + | |||
| + | ===Member functions=== | ||
| + | {{dsc begin}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc constructor | shared_mutex}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc destructor | shared_mutex}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc operator{{=}}}} | ||
| + | |||
| + | {{dsc h2 | Exclusive locking}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc lock | shared_mutex}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc try_lock | shared_mutex}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc unlock | shared_mutex}} | ||
| + | |||
| + | {{dsc h2 | Shared locking}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc lock_shared | shared_mutex}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc try_lock_shared | shared_mutex}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc unlock_shared | shared_mutex}} | ||
| + | |||
| + | {{dsc h2 | Native handle}} | ||
| + | {{dsc inc | cpp/thread/mutex/dsc native_handle | shared_mutex}} | ||
| + | {{dsc end}} | ||
| + | |||
| + | {{todo|build a motivating example}} | ||
| + | {{example|A copy assignment operator for a class that holds resources that can handle multiple readers, but only one writer | ||
| + | |code= class R | ||
| + | { | ||
| + | mutable std::shared_timed_mutex mut; | ||
| + | /* data */ | ||
| + | public: | ||
| + | R& operator=(const R& other) | ||
| + | { | ||
| + | // requires exclusive ownership to write to *this | ||
| + | std::unique_lock<std::shared_mutex> lhs(mut, std::defer_lock); | ||
| + | // requires shared ownership to read from other | ||
| + | std::shared_lock<std::shared_mutex> rhs(other.mut, std::defer_lock); | ||
| + | std::lock(lhs, rhs); | ||
| + | /* assign data */ | ||
| + | return *this; | ||
| + | } | ||
| + | } | ||
| + | }} | ||
| + | |||
| + | ===See also=== | ||
| + | {{dsc begin}} | ||
| + | {{dsc inc | cpp/thread/dsc shared_timed_mutex}} | ||
| + | {{dsc end}} | ||
Revision as of 12:28, 2 June 2015
| Defined in header <shared_mutex>
|
||
| class shared_mutex; |
(since C++17) | |
The shared_mutex class is a synchronization primitive that can be used to protect shared data from being simultaneously accessed by multiple threads. In contrast to other mutex types which facilitate exclusive access, a shared_mutex has two levels of access:
- shared - several threads can share ownership of the same mutex.
- exclusive - only one thread can own the mutex.
Shared mutexes are usually used in situations when multiple readers can access the same resource at the same time without causing data races, but only one writer can do so.
The shared_mutex class satisfies all requirements of Template:concept and Template:concept.
Contents |
Member functions
| constructs the mutex (public member function) | |
| destroys the mutex (public member function) | |
| operator= [deleted] |
not copy-assignable (public member function) |
Exclusive locking | |
| locks the mutex, blocks if the mutex is not available (public member function) | |
| tries to lock the mutex, returns if the mutex is not available (public member function) | |
| unlocks the mutex (public member function) | |
| | |
| locks the mutex for shared ownership, blocks if the mutex is not available (public member function) | |
| tries to lock the mutex for shared ownership, returns if the mutex is not available (public member function) | |
| unlocks the mutex (shared ownership) (public member function) | |
Native handle | |
| returns the underlying implementation-defined native handle object (public member function) | |
| This section is incomplete Reason: build a motivating example |
A copy assignment operator for a class that holds resources that can handle multiple readers, but only one writer
Run this code
class R { mutable std::shared_timed_mutex mut; /* data */ public: R& operator=(const R& other) { // requires exclusive ownership to write to *this std::unique_lock<std::shared_mutex> lhs(mut, std::defer_lock); // requires shared ownership to read from other std::shared_lock<std::shared_mutex> rhs(other.mut, std::defer_lock); std::lock(lhs, rhs); /* assign data */ return *this; } }
See also
| (C++14) |
provides shared mutual exclusion facility and implements locking with a timeout (class) |
