C++ named requirements: SharedTimedMutex (since C++14)

The SharedTimedMutex requirements extend the TimedMutex requirements to include shared lock ownership mode.

Additionally, an object m of SharedTimedMutex type supports timed shared operations:

Behaves as an atomic operation.
Attempts to obtain shared ownership of the mutex within the duration specified by duration. If duration is less or equal duration.zero(), attempts to obtain the ownership without waiting (as if by try_lock()). Otherwise, this function blocks until the mutex is acquired or until the time specified by duration passes. It returns within duration only if it succeeds, but it allowed to fail to acquire the mutex even if at some point in time during duration it was not owned by another thread. In any case, it returns true if the mutex was acquired and false otherwise.
If try_lock_shared_for(duration) succeeds, prior unlock() operations on the same object synchronize-with this operation (equivalent to release-acquire std::memory_order).
The behavior is undefined if the calling thread already owns the mutex in any mode.
An exception may be thrown by clock, time point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw).
If an exception is thrown, the shared lock is not acquired.

Behaves as an atomic operation.
Attempts to obtain shared ownership of the mutex within the time left until time_point. If time_point already passed, attempts to obtain the ownership without locking (as if by try_lock()). Otherwise, this function blocks until the mutex is acquired or until the time specified by time_point passes. It returns before time_point only if it succeeds, but it allowed to fail to acquire the mutex even if at some point in time before time_point it was not owned by another thread. In any case, it returns true if the mutex was acquired and false otherwise.
If try_lock_shared_until(time_point) succeeds, prior unlock() operations on the same object synchronize-with this operation (equivalent to release-acquire std::memory_order).
The behavior is undefined if the calling thread already owns the mutex in any mode.
An exception may be thrown by clock, time point, or duration during the execution (clocks, time points, and durations provided by the standard library never throw).
If an exception is thrown, the shared lock is not acquired.

The following standard library types satisfy SharedTimedMutex:

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries