Namespaces
Variants
Views
Actions

std::shared_mutex

From cppreference.com
< cpp‎ | thread
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 SharedMutex and StandardLayoutType.

Contents

[edit] Member types

Member type Definition
native_handle_type implementation-defined

[edit] Member functions

constructs the mutex
(public member function) [edit]
destroys the mutex
(public member function) [edit]
operator=
[deleted]
not copy-assignable
(public member function) [edit]
Exclusive locking
locks the mutex, blocks if the mutex is not available
(public member function) [edit]
tries to lock the mutex, returns if the mutex is not available
(public member function) [edit]
unlocks the mutex
(public member function) [edit]
Shared locking
locks the mutex for shared ownership, blocks if the mutex is not available
(public member function) [edit]
tries to lock the mutex for shared ownership, returns if the mutex is not available
(public member function) [edit]
unlocks the mutex (shared ownership)
(public member function) [edit]
Native handle
returns the underlying implementation-defined thread handle
(public member function) [edit]

A copy assignment operator for a class that holds resources that can handle multiple readers, but only one writer

class R
{
    mutable std::shared_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;
    }
}


[edit] See also

provides shared mutual exclusion facility
(class) [edit]