SysTutorials

Linux Manual Pages › Section 3

stdshared_timed_mutex(3)

std::shared_timed_mutex - std::shared_timed_mutex

Synopsis

Defined in header <shared_mutex> class shared_timed_mutex; (since C++14) The shared_timed_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_timed_mutex has two levels of access:

Member functions

                      constructs the mutex constructor (public member function)                       destroys the mutex destructor (public member function)

operator= not copy-assignable                       (public member function) [deleted]

 Exclusive locking

                      locks the mutex, blocks if the mutex is not available lock (public member function)                       tries to lock the mutex, returns if the mutex is not available try_lock (public member function)                       tries to lock the mutex, returns if the mutex has been try_lock_for unavailable for the specified timeout duration                       (public member function)                       tries to lock the mutex, returns if the mutex has been try_lock_until unavailable until specified time point has been reached                       (public member function)                       unlocks the mutex unlock (public member function)

Shared locking

                      locks the mutex for shared ownership, blocks if the mutex is not available lock_shared (public member function)                       tries to lock the mutex for shared ownership, returns if the mutex is not available try_lock_shared (public member function)                       tries to lock the mutex for shared ownership, returns if the mutex has been try_lock_shared_for unavailable for the specified timeout duration                       (public member function)                       tries to lock the mutex for shared ownership, returns if the mutex has been try_lock_shared_until unavailable until specified time point has been reached                       (public member function)                       unlocks the mutex (shared ownership) unlock_shared (public member function)

Example

 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

#include <mutex>
#include <shared_mutex>
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_timed_mutex> lhs(mut, std::defer_lock);
// requires shared ownership to read from other
std::shared_lock<std::shared_timed_mutex> rhs(other.mut, std::defer_lock);
std::lock(lhs, rhs);
/ assign data */
return *this;
}
};
int main()
{
R r;
}