std::shared_timed_mutex

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Thread support library

Threads
thread (C++11)
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)(C++17)
this_thread namespace
get_id (C++11) yield (C++11)	sleep_for (C++11) sleep_until (C++11)
Mutual exclusion
mutex (C++11) recursive_mutex (C++11) shared_mutex (C++17)	timed_mutex (C++11) recursive_timed_mutex (C++11) shared_timed_mutex (C++14)
Generic lock management
lock_guard (C++11) unique_lock (C++11) shared_lock (C++14) defer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)	lock (C++11) try_lock (C++11) defer_locktry_to_lockadopt_lock (C++11)(C++11)(C++11) once_flag (C++11) call_once (C++11)
Condition variables
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Futures
promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11)	launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11)

 

std::shared_timed_mutex

Member functions

shared_timed_mutex::shared_timed_mutex

Exclusive locking

shared_timed_mutex::lock

shared_timed_mutex::try_lock

shared_timed_mutex::try_lock_for

shared_timed_mutex::try_lock_until

shared_timed_mutex::unlock

Shared locking

shared_timed_mutex::lock_shared

shared_timed_mutex::try_lock_shared

shared_timed_mutex::try_lock_shared_for

shared_timed_mutex::try_lock_shared_until

shared_timed_mutex::unlock_shared

 

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:

• 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.

In a manner similar to timed_mutex, shared_timed_mutex provides the ability to attempt to claim ownership of a shared_timed_mutex with a timeout via the try_lock_for(), try_lock_until(), try_lock_shared_for(), try_lock_shared_until() methods.

The shared_timed_mutex class satisfies all requirements of SharedTimedMutex and StandardLayoutType.

Member functions

(constructor)	constructs the mutex (public member function)
(destructor)	destroys the mutex (public member function)
operator= [deleted]	not copy-assignable (public member function)
Exclusive locking
lock	locks the mutex, blocks if the mutex is not available (public member function)
try_lock	tries to lock the mutex, returns if the mutex is not available (public member function)
try_lock_for	tries to lock the mutex, returns if the mutex has been unavailable for the specified timeout duration (public member function)
try_lock_until	tries to lock the mutex, returns if the mutex has been unavailable until specified time point has been reached (public member function)
unlock	unlocks the mutex (public member function)
Shared locking
lock_shared	locks the mutex for shared ownership, blocks if the mutex is not available (public member function)
try_lock_shared	tries to lock the mutex for shared ownership, returns if the mutex is not available (public member function)
try_lock_shared_for	tries to lock the mutex for shared ownership, returns if the mutex has been unavailable for the specified timeout duration (public member function)
try_lock_shared_until	tries to lock the mutex for shared ownership, returns if the mutex has been unavailable until specified time point has been reached (public member function)
unlock_shared	unlocks the mutex (shared ownership) (public member function)

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_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;
    }
}