33 Thread support library [thread]

33.4 Mutual exclusion [thread.mutex]

33.4.3 Mutex requirements [thread.mutex.requirements]

33.4.3.5 Shared timed mutex types [thread.sharedtimedmutex.requirements]

1
#
The standard library type shared_­timed_­mutex is a shared timed mutex type.
Shared timed mutex types shall meet the requirements of timed mutex types ([thread.timedmutex.requirements]), shared mutex types ([thread.sharedmutex.requirements]), and additionally shall meet the requirements set out below.
In this description, m denotes an object of a shared timed mutex type, rel_­type denotes an object of an instantiation of duration ([time.duration]), and abs_­time denotes an object of an instantiation of time_­point ([time.point]).
2
#
The expression m.try_­lock_­shared_­for(rel_­time) shall be well-formed and have the following semantics:
3
#
Requires: The calling thread has no ownership of the mutex.
4
#
Effects: Attempts to obtain shared lock ownership for the calling thread within the relative timeout ([thread.req.timing]) specified by rel_­time.
If the time specified by rel_­time is less than or equal to rel_­time.zero(), the function attempts to obtain ownership without blocking (as if by calling try_­lock_­shared()).
The function shall return within the timeout specified by rel_­time only if it has obtained shared ownership of the mutex object.
[ Note
:
As with try_­lock(), there is no guarantee that ownership will be obtained if the lock is available, but implementations are expected to make a strong effort to do so.
— end note
 ]
If an exception is thrown then a shared lock shall not have been acquired for the current thread.
5
#
Return type: bool.
6
#
Returns: true if the shared lock was acquired, false otherwise.
7
#
Synchronization: If try_­lock_­shared_­for() returns true, prior unlock() operations on the same object synchronize with ([intro.multithread]) this operation.
8
#
Throws: Timeout-related exceptions ([thread.req.timing]).
9
#
The expression m.try_­lock_­shared_­until(abs_­time) shall be well-formed and have the following semantics:
10
#
Requires: The calling thread has no ownership of the mutex.
11
#
Effects: The function attempts to obtain shared ownership of the mutex.
If abs_­time has already passed, the function attempts to obtain shared ownership without blocking (as if by calling try_­lock_­shared()).
The function shall return before the absolute timeout ([thread.req.timing]) specified by abs_­time only if it has obtained shared ownership of the mutex object.
[ Note
:
As with try_­lock(), there is no guarantee that ownership will be obtained if the lock is available, but implementations are expected to make a strong effort to do so.
— end note
 ]
If an exception is thrown then a shared lock shall not have been acquired for the current thread.
12
#
Return type: bool.
13
#
Returns: true if the shared lock was acquired, false otherwise.
14
#
Synchronization: If try_­lock_­shared_­until() returns true, prior unlock() operations on the same object synchronize with ([intro.multithread]) this operation.
15
#
Throws: Timeout-related exceptions ([thread.req.timing]).

33.4.3.5.1 Class shared_­timed_­mutex [thread.sharedtimedmutex.class]

namespace std {
  class shared_timed_mutex {
  public:
    shared_timed_mutex();
    ~shared_timed_mutex();

    shared_timed_mutex(const shared_timed_mutex&) = delete;
    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;

    // Exclusive ownership
    void lock();  // blocking
    bool try_lock();
    template <class Rep, class Period>
      bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
      bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
    void unlock();

    // Shared ownership
    void lock_shared();  // blocking
    bool try_lock_shared();
    template <class Rep, class Period>
      bool
      try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
      bool
      try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
    void unlock_shared();
  };
}
1
#
The class shared_­timed_­mutex provides a non-recursive mutex with shared ownership semantics.
2
#
The class shared_­timed_­mutex shall satisfy all of the shared timed mutex requirements ([thread.sharedtimedmutex.requirements]).
It shall be a standard-layout class (Clause [class]).
3
#
The behavior of a program is undefined if:
  • (3.1)
    it destroys a shared_­timed_­mutex object owned by any thread,
  • (3.2)
    a thread attempts to recursively gain any ownership of a shared_­timed_­mutex, or
  • (3.3)
    a thread terminates while possessing any ownership of a shared_­timed_­mutex.