[thread.mutex] - C++17 → C++20

Files changed (1) hide show

tmp/tmp2hkky5kp/{from.md → to.md} +325 -372

tmp/tmp2hkky5kp/{from.md → to.md} RENAMED Viewed

@@ -1,10 +1,10 @@
 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
-This section provides mechanisms for mutual exclusion: mutexes, locks,
 and call once. These mechanisms ease the production of race-free
-programs ([[intro.multithread]]).
 ### Header `<mutex>` synopsis <a id="mutex.syn">[[mutex.syn]]</a>
 ``` cpp
 namespace std {
@@ -36,11 +36,11 @@ namespace std {
   template<class Callable, class... Args>
     void call_once(once_flag& flag, Callable&& func, Args&&... args);
 }
 ```
-### Header `<shared_mutex>` synopsis <a id="shared_mutex.syn">[[shared_mutex.syn]]</a>
 ``` cpp
 namespace std {
   class shared_mutex;
   class shared_timed_mutex;
@@ -53,128 +53,129 @@ namespace std {
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
 #### In general <a id="thread.mutex.requirements.general">[[thread.mutex.requirements.general]]</a>
 A mutex object facilitates protection against data races and allows safe
-synchronization of data between execution agents (
-[[thread.req.lockable]]). An execution agent *owns* a mutex from the
-time it successfully calls one of the lock functions until it calls
-unlock. Mutexes can be either recursive or non-recursive, and can grant
 simultaneous ownership to one or many execution agents. Both recursive
 and non-recursive mutexes are supplied.
 #### Mutex types <a id="thread.mutex.requirements.mutex">[[thread.mutex.requirements.mutex]]</a>
 The *mutex types* are the standard library types `mutex`,
 `recursive_mutex`, `timed_mutex`, `recursive_timed_mutex`,
-`shared_mutex`, and `shared_timed_mutex`. They shall meet the
-requirements set out in this section. In this description, `m` denotes
-an object of a mutex type.
-The mutex types shall meet the `Lockable` requirements (
-[[thread.req.lockable.req]]).
-The mutex types shall be `DefaultConstructible` and `Destructible`. If
-initialization of an object of a mutex type fails, an exception of type
-`system_error` shall be thrown. The mutex types shall not be copyable or
-movable.
 The error conditions for error codes, if any, reported by member
-functions of the mutex types shall be:
 - `resource_unavailable_try_again` — if any native handle type
   manipulated is not available.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 - `invalid_argument` — if any native handle type manipulated as part of
   mutex construction is incorrect.
-The implementation shall provide lock and unlock operations, as
-described below. For purposes of determining the existence of a data
-race, these behave as atomic operations ([[intro.multithread]]). The
-lock and unlock operations on a single mutex shall appear to occur in a
-single total order.
-[*Note 1*: This can be viewed as the modification order (
-[[intro.multithread]]) of the mutex. — *end note*]
 [*Note 2*: Construction and destruction of an object of a mutex type
 need not be thread-safe; other synchronization should be used to ensure
 that mutex objects are initialized and visible to other
 threads. — *end note*]
-The expression `m.lock()` shall be well-formed and have the following
 semantics:
-*Requires:* If `m` is of type `mutex`, `timed_mutex`, `shared_mutex`, or
-`shared_timed_mutex`, the calling thread does not own the mutex.
 *Effects:* Blocks the calling thread until ownership of the mutex can be
 obtained for the calling thread.
-*Postconditions:* The calling thread owns the mutex.
 *Return type:* `void`.
-*Synchronization:* Prior `unlock()` operations on the same object shall
-*synchronize with* ([[intro.multithread]]) this operation.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 - `resource_deadlock_would_occur` — if the implementation detects that a
   deadlock would occur.
-The expression `m.try_lock()` shall be well-formed and have the
-following semantics:
-*Requires:* If `m` is of type `mutex`, `timed_mutex`, `shared_mutex`, or
-`shared_timed_mutex`, the calling thread does not own the mutex.
 *Effects:* Attempts to obtain ownership of the mutex for the calling
 thread without blocking. If ownership is not obtained, there is no
 effect and `try_lock()` immediately returns. An implementation may fail
 to obtain the lock even if it is not held by any other thread.
 [*Note 1*: This spurious failure is normally uncommon, but allows
-interesting implementations based on a simple compare and exchange
-(Clause  [[atomics]]). — *end note*]
 An implementation should ensure that `try_lock()` does not consistently
 return `false` in the absence of contending mutex acquisitions.
 *Return type:* `bool`.
 *Returns:* `true` if ownership of the mutex was obtained for the calling
 thread, otherwise `false`.
 *Synchronization:* If `try_lock()` returns `true`, prior `unlock()`
-operations on the same object *synchronize
-with* ([[intro.multithread]]) this operation.
 [*Note 2*: Since `lock()` does not synchronize with a failed subsequent
 `try_lock()`, the visibility rules are weak enough that little would be
 known about the state after a failure, even in the absence of spurious
 failures. — *end note*]
 *Throws:* Nothing.
-The expression `m.unlock()` shall be well-formed and have the following
 semantics:
-*Requires:* The calling thread shall own the mutex.
 *Effects:* Releases the calling thread’s ownership of the mutex.
 *Return type:* `void`.
 *Synchronization:* This operation synchronizes
-with ([[intro.multithread]]) subsequent lock operations that obtain
 ownership on the same object.
 *Throws:* Nothing.
 ##### Class `mutex` <a id="thread.mutex.class">[[thread.mutex.class]]</a>
@@ -191,12 +192,12 @@ namespace std {
     void lock();
     bool try_lock();
     void unlock();
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    native_handle_type native_handle(); // See~[thread.req.native]
   };
 }
 ```
 The class `mutex` provides a non-recursive mutex with exclusive
@@ -212,17 +213,17 @@ that it is no longer in use, unlock it, and destroy it, before thread
 required to handle such scenarios correctly, as long as thread `A`
 doesn’t access the mutex after the unlock call returns. These cases
 typically occur when a reference-counted object contains a mutex that is
 used to protect the reference count. — *end note*]
-The class `mutex` shall satisfy all of the mutex requirements (
-[[thread.mutex.requirements]]). It shall be a standard-layout class
-(Clause  [[class]]).
-[*Note 4*: A program may deadlock if the thread that owns a `mutex`
 object calls `lock()` on that object. If the implementation can detect
-the deadlock, a `resource_deadlock_would_occur` error condition may be
 observed. — *end note*]
 The behavior of a program is undefined if it destroys a `mutex` object
 owned by any thread or a thread terminates while owning a `mutex`
 object.
@@ -241,92 +242,92 @@ namespace std {
     void lock();
     bool try_lock() noexcept;
     void unlock();
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    native_handle_type native_handle(); // See~[thread.req.native]
   };
 }
 ```
 The class `recursive_mutex` provides a recursive mutex with exclusive
 ownership semantics. If one thread owns a `recursive_mutex` object,
 attempts by another thread to acquire ownership of that object will fail
 (for `try_lock()`) or block (for `lock()`) until the first thread has
 completely released ownership.
-The class `recursive_mutex` shall satisfy all of the mutex
-requirements ([[thread.mutex.requirements]]). It shall be a
-standard-layout class (Clause  [[class]]).
 A thread that owns a `recursive_mutex` object may acquire additional
 levels of ownership by calling `lock()` or `try_lock()` on that object.
 It is unspecified how many levels of ownership may be acquired by a
 single thread. If a thread has already acquired the maximum level of
 ownership for a `recursive_mutex` object, additional calls to
-`try_lock()` shall fail, and additional calls to `lock()` shall throw an
-exception of type `system_error`. A thread shall call `unlock()` once
-for each level of ownership acquired by calls to `lock()` and
-`try_lock()`. Only when all levels of ownership have been released may
-ownership be acquired by another thread.
 The behavior of a program is undefined if:
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
 The *timed mutex types* are the standard library types `timed_mutex`,
-`recursive_timed_mutex`, and `shared_timed_mutex`. They shall meet the
 requirements set out below. In this description, `m` denotes an object
 of a mutex type, `rel_time` denotes an object of an instantiation of
-`duration` ([[time.duration]]), and `abs_time` denotes an object of an
-instantiation of `time_point` ([[time.point]]).
-The timed mutex types shall meet the `TimedLockable` requirements (
-[[thread.req.lockable.timed]]).
-The expression `m.try_lock_for(rel_time)` shall be well-formed and have
-the following semantics:
-*Requires:* If `m` is of type `timed_mutex` or `shared_timed_mutex`, the
-calling thread does not own the mutex.
 *Effects:* The function attempts to obtain ownership of the mutex 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()`). The function shall return
-within the timeout specified by `rel_time` only if it has obtained
-ownership of the mutex object.
 [*Note 1*: 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*]
 *Return type:* `bool`.
 *Returns:* `true` if ownership was obtained, otherwise `false`.
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
-operations on the same object *synchronize
-with* ([[intro.multithread]]) this operation.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
-The expression `m.try_lock_until(abs_time)` shall be well-formed and
-have the following semantics:
-*Requires:* If `m` is of type `timed_mutex` or `shared_timed_mutex`, the
-calling thread does not own the mutex.
 *Effects:* The function attempts to obtain ownership of the mutex. If
 `abs_time` has already passed, the function attempts to obtain ownership
-without blocking (as if by calling `try_lock()`). The function shall
-return before the absolute timeout ([[thread.req.timing]]) specified by
 `abs_time` only if it has obtained ownership of the mutex object.
 [*Note 2*: 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*]
@@ -335,13 +336,13 @@ expected to make a strong effort to do so. — *end note*]
 *Returns:* `true` if ownership was obtained, otherwise `false`.
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
-with* ([[intro.multithread]]) this operation.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
 namespace std {
@@ -359,12 +360,12 @@ namespace std {
       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();
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    native_handle_type native_handle(); // See~[thread.req.native]
   };
 }
 ```
 The class `timed_mutex` provides a non-recursive mutex with exclusive
@@ -373,13 +374,13 @@ by another thread to acquire ownership of that object will fail (for
 `try_lock()`) or block (for `lock()`, `try_lock_for()`, and
 `try_lock_until()`) until the owning thread has released ownership with
 a call to `unlock()` or the call to `try_lock_for()` or
 `try_lock_until()` times out (having failed to obtain ownership).
-The class `timed_mutex` shall satisfy all of the timed mutex
-requirements ([[thread.timedmutex.requirements]]). It shall be a
-standard-layout class (Clause  [[class]]).
 The behavior of a program is undefined if:
 - it destroys a `timed_mutex` object owned by any thread,
 - a thread that owns a `timed_mutex` object calls `lock()`,
@@ -405,12 +406,12 @@ namespace std {
       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();
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    native_handle_type native_handle(); // See~[thread.req.native]
   };
 }
 ```
 The class `recursive_timed_mutex` provides a recursive mutex with
@@ -419,99 +420,99 @@ exclusive ownership semantics. If one thread owns a
 ownership of that object will fail (for `try_lock()`) or block (for
 `lock()`, `try_lock_for()`, and `try_lock_until()`) until the owning
 thread has completely released ownership or the call to `try_lock_for()`
 or `try_lock_until()` times out (having failed to obtain ownership).
-The class `recursive_timed_mutex` shall satisfy all of the timed mutex
-requirements ([[thread.timedmutex.requirements]]). It shall be a
-standard-layout class (Clause  [[class]]).
 A thread that owns a `recursive_timed_mutex` object may acquire
 additional levels of ownership by calling `lock()`, `try_lock()`,
 `try_lock_for()`, or `try_lock_until()` on that object. It is
 unspecified how many levels of ownership may be acquired by a single
 thread. If a thread has already acquired the maximum level of ownership
 for a `recursive_timed_mutex` object, additional calls to `try_lock()`,
-`try_lock_for()`, or `try_lock_until()` shall fail, and additional calls
-to `lock()` shall throw an exception of type `system_error`. A thread
-shall call `unlock()` once for each level of ownership acquired by calls
-to `lock()`, `try_lock()`, `try_lock_for()`, and `try_lock_until()`.
-Only when all levels of ownership have been released may ownership of
-the object be acquired by another thread.
 The behavior of a program is undefined if:
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
 The standard library types `shared_mutex` and `shared_timed_mutex` are
-*shared mutex types*. Shared mutex types shall meet the requirements of
-mutex types ([[thread.mutex.requirements.mutex]]), and additionally
-shall meet the requirements set out below. In this description, `m`
-denotes an object of a shared mutex type.
 In addition to the exclusive lock ownership mode specified in
 [[thread.mutex.requirements.mutex]], shared mutex types provide a
 *shared lock* ownership mode. Multiple execution agents can
 simultaneously hold a shared lock ownership of a shared mutex type. But
-no execution agent shall hold a shared lock while another execution
-agent holds an exclusive lock on the same shared mutex type, and
-vice-versa. The maximum number of execution agents which can share a
-shared lock on a single shared mutex type is unspecified, but shall be
-at least 10000. If more than the maximum number of execution agents
-attempt to obtain a shared lock, the excess execution agents shall block
-until the number of shared locks are reduced below the maximum amount by
-other execution agents releasing their shared lock.
-The expression `m.lock_shared()` shall be well-formed and have the
-following semantics:
-*Requires:* The calling thread has no ownership of the mutex.
 *Effects:* Blocks the calling thread until shared ownership of the mutex
 can be obtained for the calling thread. If an exception is thrown then a
-shared lock shall not have been acquired for the current thread.
-*Postconditions:* The calling thread has a shared lock on the mutex.
 *Return type:* `void`.
-*Synchronization:* Prior `unlock()` operations on the same object shall
-synchronize with ([[intro.multithread]]) this operation.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 - `resource_deadlock_would_occur` — if the implementation detects that a
   deadlock would occur.
-The expression `m.unlock_shared()` shall be well-formed and have the
-following semantics:
-*Requires:* The calling thread shall hold a shared lock on the mutex.
 *Effects:* Releases a shared lock on the mutex held by the calling
 thread.
 *Return type:* `void`.
 *Synchronization:* This operation synchronizes
-with ([[intro.multithread]]) subsequent `lock()` operations that obtain
 ownership on the same object.
 *Throws:* Nothing.
-The expression `m.try_lock_shared()` shall be well-formed and have the
 following semantics:
-*Requires:* The calling thread has no ownership of the mutex.
 *Effects:* Attempts to obtain shared ownership of the mutex for the
 calling thread without blocking. If shared ownership is not obtained,
 there is no effect and `try_lock_shared()` immediately returns. An
 implementation may fail to obtain the lock even if it is not held by any
@@ -522,15 +523,15 @@ other thread.
 *Returns:* `true` if the shared ownership lock was acquired, `false`
 otherwise.
 *Synchronization:* If `try_lock_shared()` returns `true`, prior
 `unlock()` operations on the same object synchronize
-with ([[intro.multithread]]) this operation.
 *Throws:* Nothing.
-##### Class shared_mutex <a id="thread.sharedmutex.class">[[thread.sharedmutex.class]]</a>
 ``` cpp
 namespace std {
   class shared_mutex {
   public:
@@ -538,32 +539,32 @@ namespace std {
     ~shared_mutex();
     shared_mutex(const shared_mutex&) = delete;
     shared_mutex& operator=(const shared_mutex&) = delete;
-    // Exclusive ownership
     void lock();                // blocking
     bool try_lock();
     void unlock();
-    // Shared ownership
     void lock_shared();         // blocking
     bool try_lock_shared();
     void unlock_shared();
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    native_handle_type native_handle(); // See~[thread.req.native]
   };
 }
 ```
 The class `shared_mutex` provides a non-recursive mutex with shared
 ownership semantics.
-The class `shared_mutex` shall satisfy all of the shared mutex
-requirements ([[thread.sharedmutex.requirements]]). It shall be a
-standard-layout class (Clause  [[class]]).
 The behavior of a program is undefined if:
 - it destroys a `shared_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
@@ -574,76 +575,76 @@ The behavior of a program is undefined if:
 `shared_mutex` may be a synonym for `shared_timed_mutex`.
 #### Shared timed mutex types <a id="thread.sharedtimedmutex.requirements">[[thread.sharedtimedmutex.requirements]]</a>
 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]]).
-The expression `m.try_lock_shared_for(rel_time)` shall be well-formed
-and have the following semantics:
-*Requires:* The calling thread has no ownership of the mutex.
 *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 1*: 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.
 *Return type:* `bool`.
 *Returns:* `true` if the shared lock was acquired, `false` otherwise.
 *Synchronization:* If `try_lock_shared_for()` returns `true`, prior
 `unlock()` operations on the same object synchronize
-with ([[intro.multithread]]) this operation.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
-The expression `m.try_lock_shared_until(abs_time)` shall be well-formed
-and have the following semantics:
-*Requires:* The calling thread has no ownership of the mutex.
 *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 2*: 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.
 *Return type:* `bool`.
 *Returns:* `true` if the shared lock was acquired, `false` otherwise.
 *Synchronization:* If `try_lock_shared_until()` returns `true`, prior
 `unlock()` operations on the same object synchronize
-with ([[intro.multithread]]) this operation.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ##### Class `shared_timed_mutex` <a id="thread.sharedtimedmutex.class">[[thread.sharedtimedmutex.class]]</a>
 ``` cpp
 namespace std {
@@ -653,39 +654,37 @@ namespace std {
     ~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();
   };
 }
 ```
 The class `shared_timed_mutex` provides a non-recursive mutex with
 shared ownership semantics.
-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]]).
 The behavior of a program is undefined if:
 - it destroys a `shared_timed_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
@@ -741,41 +740,37 @@ namespace std {
     lock_guard& operator=(const lock_guard&) = delete;
   private:
     mutex_type& pm;             // exposition only
   };
-  template<class Mutex> lock_guard(lock_guard<Mutex>) -> lock_guard<Mutex>;
 }
 ```
 An object of type `lock_guard` controls the ownership of a lockable
 object within a scope. A `lock_guard` object maintains ownership of a
-lockable object throughout the `lock_guard` object’s lifetime (
-[[basic.life]]). The behavior of a program is undefined if the lockable
 object referenced by `pm` does not exist for the entire lifetime of the
 `lock_guard` object. The supplied `Mutex` type shall meet the
-`BasicLockable` requirements ([[thread.req.lockable.basic]]).
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
-*Requires:* If `mutex_type` is not a recursive mutex, the calling thread
-does not own the mutex `m`.
-*Effects:* As if by `m.lock()`.
-*Postconditions:* `&pm == &m`
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
-*Requires:* The calling thread owns the mutex `m`.
-*Postconditions:* `&pm == &m`
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
@@ -791,52 +786,49 @@ namespace std {
   class scoped_lock {
   public:
     using mutex_type = Mutex;   // If MutexTypes... consists of the single type Mutex
     explicit scoped_lock(MutexTypes&... m);
-    explicit scoped_lock(MutexTypes&... m, adopt_lock_t);
     ~scoped_lock();
     scoped_lock(const scoped_lock&) = delete;
     scoped_lock& operator=(const scoped_lock&) = delete;
   private:
     tuple<MutexTypes&...> pm;   // exposition only
   };
-  template<class... MutexTypes>
-    scoped_lock(scoped_lock<MutexTypes...>) -> scoped_lock<MutexTypes...>;
 }
 ```
 An object of type `scoped_lock` controls the ownership of lockable
 objects within a scope. A `scoped_lock` object maintains ownership of
-lockable objects throughout the `scoped_lock` object’s lifetime (
-[[basic.life]]). The behavior of a program is undefined if the lockable
 objects referenced by `pm` do not exist for the entire lifetime of the
 `scoped_lock` object. When `sizeof...(MutexTypes)` is `1`, the supplied
-`Mutex` type shall meet the `BasicLockable` requirements (
-[[thread.req.lockable.basic]]). Otherwise, each of the mutex types shall
-meet the `Lockable` requirements ([[thread.req.lockable.req]]).
 ``` cpp
 explicit scoped_lock(MutexTypes&... m);
 ```
-*Requires:* If a `MutexTypes` type is not a recursive mutex, the calling
-thread does not own the corresponding mutex element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`. Then if
 `sizeof...(MutexTypes)` is `0`, no effects. Otherwise if
 `sizeof...(MutexTypes)` is `1`, then `m.lock()`. Otherwise,
 `lock(m...)`.
 ``` cpp
-explicit scoped_lock(MutexTypes&... m, adopt_lock_t);
 ```
-*Requires:* The calling thread owns all the mutexes in `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
@@ -897,12 +889,10 @@ namespace std {
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
-  template<class Mutex> unique_lock(unique_lock<Mutex>) -> unique_lock<Mutex>;
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
@@ -911,123 +901,113 @@ object within a scope. Ownership of the lockable object may be acquired
 at construction or after construction, and may be transferred, after
 acquisition, to another `unique_lock` object. Objects of type
 `unique_lock` are not copyable but are movable. The behavior of a
 program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
-remaining lifetime ([[basic.life]]) of the `unique_lock` object. The
-supplied `Mutex` type shall meet the `BasicLockable` requirements (
-[[thread.req.lockable.basic]]).
-[*Note 1*: `unique_lock<Mutex>` meets the `BasicLockable` requirements.
-If `Mutex` meets the `Lockable` requirements (
-[[thread.req.lockable.req]]), `unique_lock<Mutex>` also meets the
-`Lockable` requirements; if `Mutex` meets the `TimedLockable`
-requirements ([[thread.req.lockable.timed]]), `unique_lock<Mutex>` also
-meets the `TimedLockable` requirements. — *end note*]
-##### `unique_lock` constructors, destructor, and assignment <a id="thread.lock.unique.cons">[[thread.lock.unique.cons]]</a>
 ``` cpp
 unique_lock() noexcept;
 ```
-*Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == 0` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
-*Requires:* If `mutex_type` is not a recursive mutex the calling thread
-does not own the mutex.
-*Effects:* Constructs an object of type `unique_lock` and calls
-`m.lock()`.
-*Postconditions:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
-*Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == addressof(m)` and `owns == false`.
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
-*Requires:* The supplied `Mutex` type shall meet the `Lockable`
-requirements ([[thread.req.lockable.req]]). If `mutex_type` is not a
 recursive mutex the calling thread does not own the mutex.
-*Effects:* Constructs an object of type `unique_lock` and calls
-`m.try_lock()`.
-*Postconditions:* `pm == addressof(m)` and `owns == res`, where `res` is
-the value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
-*Requires:* The calling thread owns the mutex.
-*Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template<class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Requires:* If `mutex_type` is not a recursive mutex the calling thread
-does not own the mutex. The supplied `Mutex` type shall meet the
-`TimedLockable` requirements ([[thread.req.lockable.timed]]).
-*Effects:* Constructs an object of type `unique_lock` and calls
-`m.try_lock_until(abs_time)`.
-*Postconditions:* `pm == addressof(m)` and `owns == res`, where `res` is
-the value returned by the call to `m.try_lock_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
-*Requires:* If `mutex_type` is not a recursive mutex the calling thread
-does not own the mutex. The supplied `Mutex` type shall meet the
-`TimedLockable` requirements ([[thread.req.lockable.timed]]).
-*Effects:* Constructs an object of type `unique_lock` and calls
-`m.try_lock_for(rel_time)`.
-*Postconditions:* `pm == addressof(m)` and `owns == res`, where `res` is
-the value returned by the call to `m.try_lock_for(rel_time)`.
 ``` cpp
 unique_lock(unique_lock&& u) noexcept;
 ```
-*Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
-the state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 ``` cpp
 unique_lock& operator=(unique_lock&& u);
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
-*Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
-the state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 [*Note 1*: With a recursive mutex it is possible for both `*this` and
 `u` to own the same mutex before the assignment. In this case, `*this`
 will own the mutex after the assignment and `u` will not. — *end note*]
@@ -1038,44 +1018,44 @@ will own the mutex after the assignment and `u` will not. — *end note*]
 ~unique_lock();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
-##### `unique_lock` locking <a id="thread.lock.unique.locking">[[thread.lock.unique.locking]]</a>
 ``` cpp
 void lock();
 ```
 *Effects:* As if by `pm->lock()`.
-*Postconditions:* `owns == true`.
 *Throws:* Any exception thrown by `pm->lock()`. `system_error` when an
-exception is required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 bool try_lock();
 ```
-*Requires:* The supplied `Mutex` shall meet the `Lockable`
-requirements ([[thread.req.lockable.req]]).
 *Effects:* As if by `pm->try_lock()`.
 *Returns:* The value returned by the call to `try_lock()`.
-*Postconditions:* `owns == res`, where `res` is the value returned by
-the call to `try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
-an exception is required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -1083,22 +1063,22 @@ an exception is required ([[thread.req.exception]]).
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
-requirements ([[thread.req.lockable.timed]]).
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
 *Returns:* The value returned by the call to `try_lock_until(abs_time)`.
-*Postconditions:* `owns == res`, where `res` is the value returned by
-the call to `try_lock_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_until()`. `system_error`
-when an exception is required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -1106,22 +1086,22 @@ when an exception is required ([[thread.req.exception]]).
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
-*Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
-requirements ([[thread.req.lockable.timed]]).
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
-*Returns:* The value returned by the call to `try_lock_until(rel_time)`.
-*Postconditions:* `owns == res`, where `res` is the value returned by
-the call to `try_lock_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_for()`. `system_error`
-when an exception is required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -1130,20 +1110,20 @@ when an exception is required ([[thread.req.exception]]).
 void unlock();
 ```
 *Effects:* As if by `pm->unlock()`.
-*Postconditions:* `owns == false`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if on entry `owns` is `false`.
-##### `unique_lock` modifiers <a id="thread.lock.unique.mod">[[thread.lock.unique.mod]]</a>
 ``` cpp
 void swap(unique_lock& u) noexcept;
 ```
@@ -1153,20 +1133,20 @@ void swap(unique_lock& u) noexcept;
 mutex_type* release() noexcept;
 ```
 *Returns:* The previous value of `pm`.
-*Postconditions:* `pm == 0` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
-##### `unique_lock` observers <a id="thread.lock.unique.obs">[[thread.lock.unique.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
@@ -1198,15 +1178,13 @@ namespace std {
     explicit shared_lock(mutex_type& m);        // blocking
     shared_lock(mutex_type& m, defer_lock_t) noexcept;
     shared_lock(mutex_type& m, try_to_lock_t);
     shared_lock(mutex_type& m, adopt_lock_t);
     template<class Clock, class Duration>
-      shared_lock(mutex_type& m,
-                  const chrono::time_point<Clock, Duration>& abs_time);
     template<class Rep, class Period>
-      shared_lock(mutex_type& m,
-                const chrono::duration<Rep, Period>& rel_time);
     ~shared_lock();
     shared_lock(const shared_lock&) = delete;
     shared_lock& operator=(const shared_lock&) = delete;
@@ -1234,12 +1212,10 @@ namespace std {
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
-  template<class Mutex> shared_lock(shared_lock<Mutex>) -> shared_lock<Mutex>;
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
@@ -1248,99 +1224,89 @@ lockable object within a scope. Shared ownership of the lockable object
 may be acquired at construction or after construction, and may be
 transferred, after acquisition, to another `shared_lock` object. Objects
 of type `shared_lock` are not copyable but are movable. The behavior of
 a program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
-remaining lifetime ([[basic.life]]) of the `shared_lock` object. The
-supplied `Mutex` type shall meet the shared mutex requirements (
-[[thread.sharedtimedmutex.requirements]]).
-[*Note 1*: `shared_lock<Mutex>` meets the `TimedLockable`
-requirements ([[thread.req.lockable.timed]]). — *end note*]
-##### `shared_lock` constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
 ```
-*Effects:* Constructs an object of type `shared_lock`.
-*Postconditions:* `pm == nullptr` and `owns == false`.
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
-*Requires:* The calling thread does not own the mutex for any ownership
-mode.
-*Effects:* Constructs an object of type `shared_lock` and calls
-`m.lock_shared()`.
-*Postconditions:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 shared_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
-*Effects:* Constructs an object of type `shared_lock`.
-*Postconditions:* `pm == addressof(m)` and `owns == false`.
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
-*Requires:* The calling thread does not own the mutex for any ownership
-mode.
-*Effects:* Constructs an object of type `shared_lock` and calls
-`m.try_lock_shared()`.
-*Postconditions:* `pm == addressof(m)` and `owns == res` where `res` is
-the value returned by the call to `m.try_lock_shared()`.
 ``` cpp
 shared_lock(mutex_type& m, adopt_lock_t);
 ```
-*Requires:* The calling thread has shared ownership of the mutex.
-*Effects:* Constructs an object of type `shared_lock`.
-*Postconditions:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 template<class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Requires:* The calling thread does not own the mutex for any ownership
-mode.
-*Effects:* Constructs an object of type `shared_lock` and calls
-`m.try_lock_shared_until(abs_time)`.
-*Postconditions:* `pm == addressof(m)` and `owns == res` where `res` is
-the value returned by the call to `m.try_lock_shared_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
-*Requires:* The calling thread does not own the mutex for any ownership
-mode.
-*Effects:* Constructs an object of type `shared_lock` and calls
-`m.try_lock_shared_for(rel_time)`.
-*Postconditions:* `pm == addressof(m)` and `owns == res` where `res` is
-the value returned by the call to `m.try_lock_shared_for(rel_time)`.
 ``` cpp
 ~shared_lock();
 ```
@@ -1348,36 +1314,36 @@ the value returned by the call to `m.try_lock_shared_for(rel_time)`.
 ``` cpp
 shared_lock(shared_lock&& sl) noexcept;
 ```
-*Postconditions:* `pm == sl_p.pm` and `owns == sl_p.owns` (where `sl_p`
-is the state of `sl` just prior to this construction),
-`sl.pm == nullptr` and `sl.owns == false`.
 ``` cpp
 shared_lock& operator=(shared_lock&& sl) noexcept;
 ```
 *Effects:* If `owns` calls `pm->unlock_shared()`.
-*Postconditions:* `pm == sl_p.pm` and `owns == sl_p.owns` (where `sl_p`
-is the state of `sl` just prior to this assignment), `sl.pm == nullptr`
-and `sl.owns == false`.
-##### `shared_lock` locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
 ``` cpp
 void lock();
 ```
 *Effects:* As if by `pm->lock_shared()`.
-*Postconditions:* `owns == true`.
 *Throws:* Any exception thrown by `pm->lock_shared()`. `system_error`
-when an exception is required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -1388,39 +1354,36 @@ bool try_lock();
 *Effects:* As if by `pm->try_lock_shared()`.
 *Returns:* The value returned by the call to `pm->try_lock_shared()`.
-*Postconditions:* `owns == res`, where `res` is the value returned by
-the call to `pm->try_lock_shared()`.
 *Throws:* Any exception thrown by `pm->try_lock_shared()`.
-`system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 template<class Clock, class Duration>
-  bool
-  try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *Effects:* As if by `pm->try_lock_shared_until(abs_time)`.
 *Returns:* The value returned by the call to
 `pm->try_lock_shared_until(abs_time)`.
-*Postconditions:* `owns == res`, where `res` is the value returned by
-the call to `pm->try_lock_shared_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
-`system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -1433,16 +1396,15 @@ template <class Rep, class Period>
 *Effects:* As if by `pm->try_lock_shared_for(rel_time)`.
 *Returns:* The value returned by the call to
 `pm->try_lock_shared_for(rel_time)`.
-*Postconditions:* `owns == res`, where `res` is the value returned by
-the call to `pm->try_lock_shared_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
-`system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
@@ -1451,20 +1413,20 @@ required ([[thread.req.exception]]).
 void unlock();
 ```
 *Effects:* As if by `pm->unlock_shared()`.
-*Postconditions:* `owns == false`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `operation_not_permitted` — if on entry `owns` is `false`.
-##### `shared_lock` modifiers <a id="thread.lock.shared.mod">[[thread.lock.shared.mod]]</a>
 ``` cpp
 void swap(shared_lock& sl) noexcept;
 ```
@@ -1474,20 +1436,20 @@ void swap(shared_lock& sl) noexcept;
 mutex_type* release() noexcept;
 ```
 *Returns:* The previous value of `pm`.
-*Postconditions:* `pm == nullptr` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
-##### `shared_lock` observers <a id="thread.lock.shared.obs">[[thread.lock.shared.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
@@ -1509,48 +1471,47 @@ mutex_type* mutex() const noexcept;
 ``` cpp
 template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
 ```
-*Requires:* Each template parameter type shall meet the `Lockable`
 requirements.
 [*Note 1*: The `unique_lock` class template meets these requirements
 when suitably instantiated. — *end note*]
 *Effects:* Calls `try_lock()` for each argument in order beginning with
 the first until all arguments have been processed or a call to
 `try_lock()` fails, either by returning `false` or by throwing an
-exception. If a call to `try_lock()` fails, `unlock()` shall be called
-for all prior arguments and there shall be no further calls to
-`try_lock()`.
 *Returns:* `-1` if all calls to `try_lock()` returned `true`, otherwise
 a zero-based index value that indicates the argument for which
 `try_lock()` returned `false`.
 ``` cpp
 template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
 ```
-*Requires:* Each template parameter type shall meet the `Lockable`
-requirements,
 [*Note 2*: The `unique_lock` class template meets these requirements
 when suitably instantiated. — *end note*]
 *Effects:* All arguments are locked via a sequence of calls to `lock()`,
-`try_lock()`, or `unlock()` on each argument. The sequence of calls
-shall not result in deadlock, but is otherwise unspecified.
 [*Note 3*: A deadlock avoidance algorithm such as try-and-back-off must
 be used, but the specific algorithm is not specified to avoid
 over-constraining implementations. — *end note*]
-If a call to `lock()` or `try_lock()` throws an exception, `unlock()`
-shall be called for any argument that had been locked by a call to
-`lock()` or `try_lock()`.
 ### Call once <a id="thread.once">[[thread.once]]</a>
 #### Struct `once_flag` <a id="thread.once.onceflag">[[thread.once.onceflag]]</a>
@@ -1570,57 +1531,49 @@ to initialize data without causing a data race or deadlock.
 ``` cpp
 constexpr once_flag() noexcept;
 ```
-*Effects:* Constructs an object of type `once_flag`.
 *Synchronization:* The construction of a `once_flag` object is not
 synchronized.
-*Postconditions:* The object’s internal state is set to indicate to an
 invocation of `call_once` with the object as its initial argument that
 no function has been called.
 #### Function `call_once` <a id="thread.once.callonce">[[thread.once.callonce]]</a>
 ``` cpp
 template<class Callable, class... Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 ```
-*Requires:*
-``` cpp
-INVOKE(std::forward<Callable>(func), std::forward<Args>(args)...)
-```
-(see [[func.require]]) shall be a valid expression.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
-is an *active* execution. An active execution shall call *INVOKE*(
 std::forward\<Callable\>(func), std::forward\<Args\>(args)...). If such
 a call to `func` throws an exception the execution is *exceptional*,
-otherwise it is *returning*. An exceptional execution shall propagate
-the exception to the caller of `call_once`. Among all executions of
-`call_once` for any given `once_flag`: at most one shall be a returning
-execution; if there is a returning execution, it shall be the last
-active execution; and there are passive executions only if there is a
-returning execution.
 [*Note 1*: Passive executions allow other threads to reliably observe
 the results produced by the earlier returning execution. — *end note*]
 *Synchronization:* For any given `once_flag`: all active executions
 occur in a total order; completion of an active execution synchronizes
-with ([[intro.multithread]]) the start of the next one in this total
 order; and the returning execution synchronizes with the return from all
 passive executions.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]), or any exception thrown by `func`.
 [*Example 1*:
 ``` cpp
 // global flag, regular function

 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
+This subclause provides mechanisms for mutual exclusion: mutexes, locks,
 and call once. These mechanisms ease the production of race-free
+programs [[intro.multithread]].
 ### Header `<mutex>` synopsis <a id="mutex.syn">[[mutex.syn]]</a>
 ``` cpp
 namespace std {
   template<class Callable, class... Args>
     void call_once(once_flag& flag, Callable&& func, Args&&... args);
 }
 ```
+### Header `<shared_mutex>` synopsis <a id="shared.mutex.syn">[[shared.mutex.syn]]</a>
 ``` cpp
 namespace std {
   class shared_mutex;
   class shared_timed_mutex;
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
 #### In general <a id="thread.mutex.requirements.general">[[thread.mutex.requirements.general]]</a>
 A mutex object facilitates protection against data races and allows safe
+synchronization of data between execution agents
+[[thread.req.lockable]]. An execution agent *owns* a mutex from the time
+it successfully calls one of the lock functions until it calls unlock.
+Mutexes can be either recursive or non-recursive, and can grant
 simultaneous ownership to one or many execution agents. Both recursive
 and non-recursive mutexes are supplied.
 #### Mutex types <a id="thread.mutex.requirements.mutex">[[thread.mutex.requirements.mutex]]</a>
 The *mutex types* are the standard library types `mutex`,
 `recursive_mutex`, `timed_mutex`, `recursive_timed_mutex`,
+`shared_mutex`, and `shared_timed_mutex`. They meet the requirements set
+out in this subclause. In this description, `m` denotes an object of a
+mutex type.
+The mutex types meet the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]].
+The mutex types meet *Cpp17DefaultConstructible* and
+*Cpp17Destructible*. If initialization of an object of a mutex type
+fails, an exception of type `system_error` is thrown. The mutex types
+are neither copyable nor movable.
 The error conditions for error codes, if any, reported by member
+functions of the mutex types are as follows:
 - `resource_unavailable_try_again` — if any native handle type
   manipulated is not available.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 - `invalid_argument` — if any native handle type manipulated as part of
   mutex construction is incorrect.
+The implementation provides lock and unlock operations, as described
+below. For purposes of determining the existence of a data race, these
+behave as atomic operations [[intro.multithread]]. The lock and unlock
+operations on a single mutex appears to occur in a single total order.
+[*Note 1*: This can be viewed as the modification order
+[[intro.multithread]] of the mutex. — *end note*]
 [*Note 2*: Construction and destruction of an object of a mutex type
 need not be thread-safe; other synchronization should be used to ensure
 that mutex objects are initialized and visible to other
 threads. — *end note*]
+The expression `m.lock()` is well-formed and has the following
 semantics:
+*Preconditions:* If `m` is of type `mutex`, `timed_mutex`,
+`shared_mutex`, or `shared_timed_mutex`, the calling thread does not own
+the mutex.
 *Effects:* Blocks the calling thread until ownership of the mutex can be
 obtained for the calling thread.
+*Ensures:* The calling thread owns the mutex.
 *Return type:* `void`.
+*Synchronization:* Prior `unlock()` operations on the same object
+*synchronize with*[[intro.multithread]] this operation.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 - `resource_deadlock_would_occur` — if the implementation detects that a
   deadlock would occur.
+The expression `m.try_lock()` is well-formed and has the following
+semantics:
+*Preconditions:* If `m` is of type `mutex`, `timed_mutex`,
+`shared_mutex`, or `shared_timed_mutex`, the calling thread does not own
+the mutex.
 *Effects:* Attempts to obtain ownership of the mutex for the calling
 thread without blocking. If ownership is not obtained, there is no
 effect and `try_lock()` immediately returns. An implementation may fail
 to obtain the lock even if it is not held by any other thread.
 [*Note 1*: This spurious failure is normally uncommon, but allows
+interesting implementations based on a simple compare and
+exchange [[atomics]]. — *end note*]
 An implementation should ensure that `try_lock()` does not consistently
 return `false` in the absence of contending mutex acquisitions.
 *Return type:* `bool`.
 *Returns:* `true` if ownership of the mutex was obtained for the calling
 thread, otherwise `false`.
 *Synchronization:* If `try_lock()` returns `true`, prior `unlock()`
+operations on the same object *synchronize with*[[intro.multithread]]
+this operation.
 [*Note 2*: Since `lock()` does not synchronize with a failed subsequent
 `try_lock()`, the visibility rules are weak enough that little would be
 known about the state after a failure, even in the absence of spurious
 failures. — *end note*]
 *Throws:* Nothing.
+The expression `m.unlock()` is well-formed and has the following
 semantics:
+*Preconditions:* The calling thread owns the mutex.
 *Effects:* Releases the calling thread’s ownership of the mutex.
 *Return type:* `void`.
 *Synchronization:* This operation synchronizes
+with [[intro.multithread]] subsequent lock operations that obtain
 ownership on the same object.
 *Throws:* Nothing.
 ##### Class `mutex` <a id="thread.mutex.class">[[thread.mutex.class]]</a>
     void lock();
     bool try_lock();
     void unlock();
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    native_handle_type native_handle(); // see~[thread.req.native]
   };
 }
 ```
 The class `mutex` provides a non-recursive mutex with exclusive
 required to handle such scenarios correctly, as long as thread `A`
 doesn’t access the mutex after the unlock call returns. These cases
 typically occur when a reference-counted object contains a mutex that is
 used to protect the reference count. — *end note*]
+The class `mutex` meets all of the mutex requirements
+[[thread.mutex.requirements]]. It is a standard-layout class
+[[class.prop]].
+[*Note 4*: A program can deadlock if the thread that owns a `mutex`
 object calls `lock()` on that object. If the implementation can detect
+the deadlock, a `resource_deadlock_would_occur` error condition might be
 observed. — *end note*]
 The behavior of a program is undefined if it destroys a `mutex` object
 owned by any thread or a thread terminates while owning a `mutex`
 object.
     void lock();
     bool try_lock() noexcept;
     void unlock();
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    native_handle_type native_handle(); // see~[thread.req.native]
   };
 }
 ```
 The class `recursive_mutex` provides a recursive mutex with exclusive
 ownership semantics. If one thread owns a `recursive_mutex` object,
 attempts by another thread to acquire ownership of that object will fail
 (for `try_lock()`) or block (for `lock()`) until the first thread has
 completely released ownership.
+The class `recursive_mutex` meets all of the mutex requirements
+[[thread.mutex.requirements]]. It is a standard-layout class
+[[class.prop]].
 A thread that owns a `recursive_mutex` object may acquire additional
 levels of ownership by calling `lock()` or `try_lock()` on that object.
 It is unspecified how many levels of ownership may be acquired by a
 single thread. If a thread has already acquired the maximum level of
 ownership for a `recursive_mutex` object, additional calls to
+`try_lock()` fail, and additional calls to `lock()` throw an exception
+of type `system_error`. A thread shall call `unlock()` once for each
+level of ownership acquired by calls to `lock()` and `try_lock()`. Only
+when all levels of ownership have been released may ownership be
+acquired by another thread.
 The behavior of a program is undefined if:
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
 The *timed mutex types* are the standard library types `timed_mutex`,
+`recursive_timed_mutex`, and `shared_timed_mutex`. They meet the
 requirements set out below. In this description, `m` denotes an object
 of a mutex type, `rel_time` denotes an object of an instantiation of
+`duration` [[time.duration]], and `abs_time` denotes an object of an
+instantiation of `time_point` [[time.point]].
+The timed mutex types meet the *Cpp17TimedLockable* requirements
+[[thread.req.lockable.timed]].
+The expression `m.try_lock_for(rel_time)` is well-formed and has the
+following semantics:
+*Preconditions:* If `m` is of type `timed_mutex` or
+`shared_timed_mutex`, the calling thread does not own the mutex.
 *Effects:* The function attempts to obtain ownership of the mutex 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()`). The function returns within
+the timeout specified by `rel_time` only if it has obtained ownership of
+the mutex object.
 [*Note 1*: 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*]
 *Return type:* `bool`.
 *Returns:* `true` if ownership was obtained, otherwise `false`.
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
+operations on the same object *synchronize with*[[intro.multithread]]
+this operation.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
+The expression `m.try_lock_until(abs_time)` is well-formed and has the
+following semantics:
+*Preconditions:* If `m` is of type `timed_mutex` or
+`shared_timed_mutex`, the calling thread does not own the mutex.
 *Effects:* The function attempts to obtain ownership of the mutex. If
 `abs_time` has already passed, the function attempts to obtain ownership
+without blocking (as if by calling `try_lock()`). The function returns
+before the absolute timeout [[thread.req.timing]] specified by
 `abs_time` only if it has obtained ownership of the mutex object.
 [*Note 2*: 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*]
 *Returns:* `true` if ownership was obtained, otherwise `false`.
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
+with*[[intro.multithread]] this operation.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
 namespace std {
       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();
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    native_handle_type native_handle(); // see~[thread.req.native]
   };
 }
 ```
 The class `timed_mutex` provides a non-recursive mutex with exclusive
 `try_lock()`) or block (for `lock()`, `try_lock_for()`, and
 `try_lock_until()`) until the owning thread has released ownership with
 a call to `unlock()` or the call to `try_lock_for()` or
 `try_lock_until()` times out (having failed to obtain ownership).
+The class `timed_mutex` meets all of the timed mutex requirements
+[[thread.timedmutex.requirements]]. It is a standard-layout class
+[[class.prop]].
 The behavior of a program is undefined if:
 - it destroys a `timed_mutex` object owned by any thread,
 - a thread that owns a `timed_mutex` object calls `lock()`,
       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();
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    native_handle_type native_handle(); // see~[thread.req.native]
   };
 }
 ```
 The class `recursive_timed_mutex` provides a recursive mutex with
 ownership of that object will fail (for `try_lock()`) or block (for
 `lock()`, `try_lock_for()`, and `try_lock_until()`) until the owning
 thread has completely released ownership or the call to `try_lock_for()`
 or `try_lock_until()` times out (having failed to obtain ownership).
+The class `recursive_timed_mutex` meets all of the timed mutex
+requirements [[thread.timedmutex.requirements]]. It is a standard-layout
+class [[class.prop]].
 A thread that owns a `recursive_timed_mutex` object may acquire
 additional levels of ownership by calling `lock()`, `try_lock()`,
 `try_lock_for()`, or `try_lock_until()` on that object. It is
 unspecified how many levels of ownership may be acquired by a single
 thread. If a thread has already acquired the maximum level of ownership
 for a `recursive_timed_mutex` object, additional calls to `try_lock()`,
+`try_lock_for()`, or `try_lock_until()` fail, and additional calls to
+`lock()` throw an exception of type `system_error`. A thread shall call
+`unlock()` once for each level of ownership acquired by calls to
+`lock()`, `try_lock()`, `try_lock_for()`, and `try_lock_until()`. Only
+when all levels of ownership have been released may ownership of the
+object be acquired by another thread.
 The behavior of a program is undefined if:
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
 The standard library types `shared_mutex` and `shared_timed_mutex` are
+*shared mutex types*. Shared mutex types meet the requirements of mutex
+types [[thread.mutex.requirements.mutex]] and additionally meet the
+requirements set out below. In this description, `m` denotes an object
+of a shared mutex type.
 In addition to the exclusive lock ownership mode specified in
 [[thread.mutex.requirements.mutex]], shared mutex types provide a
 *shared lock* ownership mode. Multiple execution agents can
 simultaneously hold a shared lock ownership of a shared mutex type. But
+no execution agent holds a shared lock while another execution agent
+holds an exclusive lock on the same shared mutex type, and vice-versa.
+The maximum number of execution agents which can share a shared lock on
+a single shared mutex type is unspecified, but is at least 10000. If
+more than the maximum number of execution agents attempt to obtain a
+shared lock, the excess execution agents block until the number of
+shared locks are reduced below the maximum amount by other execution
+agents releasing their shared lock.
+The expression `m.lock_shared()` is well-formed and has the following
+semantics:
+*Preconditions:* The calling thread has no ownership of the mutex.
 *Effects:* Blocks the calling thread until shared ownership of the mutex
 can be obtained for the calling thread. If an exception is thrown then a
+shared lock has not been acquired for the current thread.
+*Ensures:* The calling thread has a shared lock on the mutex.
 *Return type:* `void`.
+*Synchronization:* Prior `unlock()` operations on the same object
+synchronize with [[intro.multithread]] this operation.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 - `resource_deadlock_would_occur` — if the implementation detects that a
   deadlock would occur.
+The expression `m.unlock_shared()` is well-formed and has the following
+semantics:
+*Preconditions:* The calling thread holds a shared lock on the mutex.
 *Effects:* Releases a shared lock on the mutex held by the calling
 thread.
 *Return type:* `void`.
 *Synchronization:* This operation synchronizes
+with [[intro.multithread]] subsequent `lock()` operations that obtain
 ownership on the same object.
 *Throws:* Nothing.
+The expression `m.try_lock_shared()` is well-formed and has the
 following semantics:
+*Preconditions:* The calling thread has no ownership of the mutex.
 *Effects:* Attempts to obtain shared ownership of the mutex for the
 calling thread without blocking. If shared ownership is not obtained,
 there is no effect and `try_lock_shared()` immediately returns. An
 implementation may fail to obtain the lock even if it is not held by any
 *Returns:* `true` if the shared ownership lock was acquired, `false`
 otherwise.
 *Synchronization:* If `try_lock_shared()` returns `true`, prior
 `unlock()` operations on the same object synchronize
+with [[intro.multithread]] this operation.
 *Throws:* Nothing.
+##### Class `shared_mutex` <a id="thread.sharedmutex.class">[[thread.sharedmutex.class]]</a>
 ``` cpp
 namespace std {
   class shared_mutex {
   public:
     ~shared_mutex();
     shared_mutex(const shared_mutex&) = delete;
     shared_mutex& operator=(const shared_mutex&) = delete;
+    // exclusive ownership
     void lock();                // blocking
     bool try_lock();
     void unlock();
+    // shared ownership
     void lock_shared();         // blocking
     bool try_lock_shared();
     void unlock_shared();
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    native_handle_type native_handle(); // see~[thread.req.native]
   };
 }
 ```
 The class `shared_mutex` provides a non-recursive mutex with shared
 ownership semantics.
+The class `shared_mutex` meets all of the shared mutex requirements
+[[thread.sharedmutex.requirements]]. It is a standard-layout class
+[[class.prop]].
 The behavior of a program is undefined if:
 - it destroys a `shared_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
 `shared_mutex` may be a synonym for `shared_timed_mutex`.
 #### Shared timed mutex types <a id="thread.sharedtimedmutex.requirements">[[thread.sharedtimedmutex.requirements]]</a>
 The standard library type `shared_timed_mutex` is a *shared timed mutex
+type*. Shared timed mutex types meet the requirements of timed mutex
+types [[thread.timedmutex.requirements]], shared mutex types
+[[thread.sharedmutex.requirements]], and additionally 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]].
+The expression `m.try_lock_shared_for(rel_time)` is well-formed and has
+the following semantics:
+*Preconditions:* The calling thread has no ownership of the mutex.
 *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 returns
+within the timeout specified by `rel_time` only if it has obtained
+shared ownership of the mutex object.
 [*Note 1*: 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 has not been acquired for
+the current thread.
 *Return type:* `bool`.
 *Returns:* `true` if the shared lock was acquired, `false` otherwise.
 *Synchronization:* If `try_lock_shared_for()` returns `true`, prior
 `unlock()` operations on the same object synchronize
+with [[intro.multithread]] this operation.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
+The expression `m.try_lock_shared_until(abs_time)` is well-formed and
+has the following semantics:
+*Preconditions:* The calling thread has no ownership of the mutex.
 *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 returns before the absolute
+timeout [[thread.req.timing]] specified by `abs_time` only if it has
 obtained shared ownership of the mutex object.
 [*Note 2*: 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 has not been acquired for
+the current thread.
 *Return type:* `bool`.
 *Returns:* `true` if the shared lock was acquired, `false` otherwise.
 *Synchronization:* If `try_lock_shared_until()` returns `true`, prior
 `unlock()` operations on the same object synchronize
+with [[intro.multithread]] this operation.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `shared_timed_mutex` <a id="thread.sharedtimedmutex.class">[[thread.sharedtimedmutex.class]]</a>
 ``` cpp
 namespace std {
     ~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();
   };
 }
 ```
 The class `shared_timed_mutex` provides a non-recursive mutex with
 shared ownership semantics.
+The class `shared_timed_mutex` meets all of the shared timed mutex
+requirements [[thread.sharedtimedmutex.requirements]]. It is a
+standard-layout class [[class.prop]].
 The behavior of a program is undefined if:
 - it destroys a `shared_timed_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
     lock_guard& operator=(const lock_guard&) = delete;
   private:
     mutex_type& pm;             // exposition only
   };
 }
 ```
 An object of type `lock_guard` controls the ownership of a lockable
 object within a scope. A `lock_guard` object maintains ownership of a
+lockable object throughout the `lock_guard` object’s lifetime
+[[basic.life]]. The behavior of a program is undefined if the lockable
 object referenced by `pm` does not exist for the entire lifetime of the
 `lock_guard` object. The supplied `Mutex` type shall meet the
+*Cpp17BasicLockable* requirements [[thread.req.lockable.basic]].
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex, the calling
+thread does not own the mutex `m`.
+*Effects:* Initializes `pm` with `m`. Calls `m.lock()`.
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread owns the mutex `m`.
+*Effects:* Initializes `pm` with `m`.
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
   class scoped_lock {
   public:
     using mutex_type = Mutex;   // If MutexTypes... consists of the single type Mutex
     explicit scoped_lock(MutexTypes&... m);
+    explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
     ~scoped_lock();
     scoped_lock(const scoped_lock&) = delete;
     scoped_lock& operator=(const scoped_lock&) = delete;
   private:
     tuple<MutexTypes&...> pm;   // exposition only
   };
 }
 ```
 An object of type `scoped_lock` controls the ownership of lockable
 objects within a scope. A `scoped_lock` object maintains ownership of
+lockable objects throughout the `scoped_lock` object’s lifetime
+[[basic.life]]. The behavior of a program is undefined if the lockable
 objects referenced by `pm` do not exist for the entire lifetime of the
 `scoped_lock` object. When `sizeof...(MutexTypes)` is `1`, the supplied
+`Mutex` type shall meet the *Cpp17BasicLockable* requirements
+[[thread.req.lockable.basic]]. Otherwise, each of the mutex types shall
+meet the *Cpp17Lockable* requirements [[thread.req.lockable.req]].
 ``` cpp
 explicit scoped_lock(MutexTypes&... m);
 ```
+*Preconditions:* If a `MutexTypes` type is not a recursive mutex, the
+calling thread does not own the corresponding mutex element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`. Then if
 `sizeof...(MutexTypes)` is `0`, no effects. Otherwise if
 `sizeof...(MutexTypes)` is `1`, then `m.lock()`. Otherwise,
 `lock(m...)`.
 ``` cpp
+explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 ```
+*Preconditions:* The calling thread owns all the mutexes in `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
 at construction or after construction, and may be transferred, after
 acquisition, to another `unique_lock` object. Objects of type
 `unique_lock` are not copyable but are movable. The behavior of a
 program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
+remaining lifetime [[basic.life]] of the `unique_lock` object. The
+supplied `Mutex` type shall meet the *Cpp17BasicLockable* requirements
+[[thread.req.lockable.basic]].
+[*Note 1*: `unique_lock<Mutex>` meets the *Cpp17BasicLockable*
+requirements. If `Mutex` meets the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]], `unique_lock<Mutex>` also meets the
+*Cpp17Lockable* requirements; if `Mutex` meets the *Cpp17TimedLockable*
+requirements [[thread.req.lockable.timed]], `unique_lock<Mutex>` also
+meets the *Cpp17TimedLockable* requirements. — *end note*]
+##### Constructors, destructor, and assignment <a id="thread.lock.unique.cons">[[thread.lock.unique.cons]]</a>
 ``` cpp
 unique_lock() noexcept;
 ```
+*Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex the calling
+thread does not own the mutex.
+*Effects:* Calls `m.lock()`.
+*Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
+*Ensures:* `pm == addressof(m)` and `owns == false`.
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
+*Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]]. If `mutex_type` is not a
 recursive mutex the calling thread does not own the mutex.
+*Effects:* Calls `m.try_lock()`.
+*Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
+value returned by the call to `m.try_lock()`.
 ``` cpp
 unique_lock(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread owns the mutex.
+*Ensures:* `pm == addressof(m)` and `owns == true`.
 *Throws:* Nothing.
 ``` cpp
 template<class Clock, class Duration>
   unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex the calling
+thread does not own the mutex. The supplied `Mutex` type meets the
+*Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
+*Effects:* Calls `m.try_lock_until(abs_time)`.
+*Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
+value returned by the call to `m.try_lock_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* If `mutex_type` is not a recursive mutex the calling
+thread does not own the mutex. The supplied `Mutex` type meets the
+*Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
+*Effects:* Calls `m.try_lock_for(rel_time)`.
+*Ensures:* `pm == addressof(m)` and `owns == res`, where `res` is the
+value returned by the call to `m.try_lock_for(rel_time)`.
 ``` cpp
 unique_lock(unique_lock&& u) noexcept;
 ```
+*Ensures:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is the
+state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 ``` cpp
 unique_lock& operator=(unique_lock&& u);
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
+*Ensures:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is the
+state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 [*Note 1*: With a recursive mutex it is possible for both `*this` and
 `u` to own the same mutex before the assignment. In this case, `*this`
 will own the mutex after the assignment and `u` will not. — *end note*]
 ~unique_lock();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
+##### Locking <a id="thread.lock.unique.locking">[[thread.lock.unique.locking]]</a>
 ``` cpp
 void lock();
 ```
 *Effects:* As if by `pm->lock()`.
+*Ensures:* `owns == true`.
 *Throws:* Any exception thrown by `pm->lock()`. `system_error` when an
+exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 bool try_lock();
 ```
+*Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
 *Returns:* The value returned by the call to `try_lock()`.
+*Ensures:* `owns == res`, where `res` is the value returned by the call
+to `try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
+an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
+*Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
 *Returns:* The value returned by the call to `try_lock_until(abs_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by the call
+to `try_lock_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_until()`. `system_error`
+when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* The supplied `Mutex` type meets the
+*Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
+*Returns:* The value returned by the call to `try_lock_for(rel_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by the call
+to `try_lock_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_for()`. `system_error`
+when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 void unlock();
 ```
 *Effects:* As if by `pm->unlock()`.
+*Ensures:* `owns == false`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if on entry `owns` is `false`.
+##### Modifiers <a id="thread.lock.unique.mod">[[thread.lock.unique.mod]]</a>
 ``` cpp
 void swap(unique_lock& u) noexcept;
 ```
 mutex_type* release() noexcept;
 ```
 *Returns:* The previous value of `pm`.
+*Ensures:* `pm == 0` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
+##### Observers <a id="thread.lock.unique.obs">[[thread.lock.unique.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
     explicit shared_lock(mutex_type& m);        // blocking
     shared_lock(mutex_type& m, defer_lock_t) noexcept;
     shared_lock(mutex_type& m, try_to_lock_t);
     shared_lock(mutex_type& m, adopt_lock_t);
     template<class Clock, class Duration>
+      shared_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template<class Rep, class Period>
+      shared_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~shared_lock();
     shared_lock(const shared_lock&) = delete;
     shared_lock& operator=(const shared_lock&) = delete;
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
 may be acquired at construction or after construction, and may be
 transferred, after acquisition, to another `shared_lock` object. Objects
 of type `shared_lock` are not copyable but are movable. The behavior of
 a program is undefined if the contained pointer `pm` is not null and the
 lockable object pointed to by `pm` does not exist for the entire
+remaining lifetime [[basic.life]] of the `shared_lock` object. The
+supplied `Mutex` type shall meet the shared mutex requirements
+[[thread.sharedtimedmutex.requirements]].
+[*Note 1*: `shared_lock<Mutex>` meets the *Cpp17TimedLockable*
+requirements [[thread.req.lockable.timed]]. — *end note*]
+##### Constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
 ```
+*Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
+*Preconditions:* The calling thread does not own the mutex for any
+ownership mode.
+*Effects:* Calls `m.lock_shared()`.
+*Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 shared_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
+*Ensures:* `pm == addressof(m)` and `owns == false`.
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
+*Preconditions:* The calling thread does not own the mutex for any
+ownership mode.
+*Effects:* Calls `m.try_lock_shared()`.
+*Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
+value returned by the call to `m.try_lock_shared()`.
 ``` cpp
 shared_lock(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread has shared ownership of the mutex.
+*Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 template<class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* The calling thread does not own the mutex for any
+ownership mode.
+*Effects:* Calls `m.try_lock_shared_until(abs_time)`.
+*Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
+value returned by the call to `m.try_lock_shared_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* The calling thread does not own the mutex for any
+ownership mode.
+*Effects:* Calls `m.try_lock_shared_for(rel_time)`.
+*Ensures:* `pm == addressof(m)` and `owns == res` where `res` is the
+value returned by the call to `m.try_lock_shared_for(rel_time)`.
 ``` cpp
 ~shared_lock();
 ```
 ``` cpp
 shared_lock(shared_lock&& sl) noexcept;
 ```
+*Ensures:* `pm == sl_p.pm` and `owns == sl_p.owns` (where `sl_p` is the
+state of `sl` just prior to this construction), `sl.pm == nullptr` and
+`sl.owns == false`.
 ``` cpp
 shared_lock& operator=(shared_lock&& sl) noexcept;
 ```
 *Effects:* If `owns` calls `pm->unlock_shared()`.
+*Ensures:* `pm == sl_p.pm` and `owns == sl_p.owns` (where `sl_p` is the
+state of `sl` just prior to this assignment), `sl.pm == nullptr` and
+`sl.owns == false`.
+##### Locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
 ``` cpp
 void lock();
 ```
 *Effects:* As if by `pm->lock_shared()`.
+*Ensures:* `owns == true`.
 *Throws:* Any exception thrown by `pm->lock_shared()`. `system_error`
+when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 *Effects:* As if by `pm->try_lock_shared()`.
 *Returns:* The value returned by the call to `pm->try_lock_shared()`.
+*Ensures:* `owns == res`, where `res` is the value returned by the call
+to `pm->try_lock_shared()`.
 *Throws:* Any exception thrown by `pm->try_lock_shared()`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 ``` cpp
 template<class Clock, class Duration>
+  bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *Effects:* As if by `pm->try_lock_shared_until(abs_time)`.
 *Returns:* The value returned by the call to
 `pm->try_lock_shared_until(abs_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by the call
+to `pm->try_lock_shared_until(abs_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_until(abs_time)`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 *Effects:* As if by `pm->try_lock_shared_for(rel_time)`.
 *Returns:* The value returned by the call to
 `pm->try_lock_shared_for(rel_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by the call
+to `pm->try_lock_shared_for(rel_time)`.
 *Throws:* Any exception thrown by `pm->try_lock_shared_for(rel_time)`.
+`system_error` when an exception is required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if `pm` is `nullptr`.
 - `resource_deadlock_would_occur` — if on entry `owns` is `true`.
 void unlock();
 ```
 *Effects:* As if by `pm->unlock_shared()`.
+*Ensures:* `owns == false`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `operation_not_permitted` — if on entry `owns` is `false`.
+##### Modifiers <a id="thread.lock.shared.mod">[[thread.lock.shared.mod]]</a>
 ``` cpp
 void swap(shared_lock& sl) noexcept;
 ```
 mutex_type* release() noexcept;
 ```
 *Returns:* The previous value of `pm`.
+*Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
+##### Observers <a id="thread.lock.shared.obs">[[thread.lock.shared.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
 ``` cpp
 template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
 ```
+*Preconditions:* Each template parameter type meets the *Cpp17Lockable*
 requirements.
 [*Note 1*: The `unique_lock` class template meets these requirements
 when suitably instantiated. — *end note*]
 *Effects:* Calls `try_lock()` for each argument in order beginning with
 the first until all arguments have been processed or a call to
 `try_lock()` fails, either by returning `false` or by throwing an
+exception. If a call to `try_lock()` fails, `unlock()` is called for all
+prior arguments with no further calls to `try_lock()`.
 *Returns:* `-1` if all calls to `try_lock()` returned `true`, otherwise
 a zero-based index value that indicates the argument for which
 `try_lock()` returned `false`.
 ``` cpp
 template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
 ```
+*Preconditions:* Each template parameter type meets the *Cpp17Lockable*
+requirements.
 [*Note 2*: The `unique_lock` class template meets these requirements
 when suitably instantiated. — *end note*]
 *Effects:* All arguments are locked via a sequence of calls to `lock()`,
+`try_lock()`, or `unlock()` on each argument. The sequence of calls does
+not result in deadlock, but is otherwise unspecified.
 [*Note 3*: A deadlock avoidance algorithm such as try-and-back-off must
 be used, but the specific algorithm is not specified to avoid
 over-constraining implementations. — *end note*]
+If a call to `lock()` or `try_lock()` throws an exception, `unlock()` is
+called for any argument that had been locked by a call to `lock()` or
+`try_lock()`.
 ### Call once <a id="thread.once">[[thread.once]]</a>
 #### Struct `once_flag` <a id="thread.once.onceflag">[[thread.once.onceflag]]</a>
 ``` cpp
 constexpr once_flag() noexcept;
 ```
 *Synchronization:* The construction of a `once_flag` object is not
 synchronized.
+*Ensures:* The object’s internal state is set to indicate to an
 invocation of `call_once` with the object as its initial argument that
 no function has been called.
 #### Function `call_once` <a id="thread.once.callonce">[[thread.once.callonce]]</a>
 ``` cpp
 template<class Callable, class... Args>
   void call_once(once_flag& flag, Callable&& func, Args&&... args);
 ```
+*Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
+is an *active* execution. An active execution calls *INVOKE*(
 std::forward\<Callable\>(func), std::forward\<Args\>(args)...). If such
 a call to `func` throws an exception the execution is *exceptional*,
+otherwise it is *returning*. An exceptional execution propagates the
+exception to the caller of `call_once`. Among all executions of
+`call_once` for any given `once_flag`: at most one is a returning
+execution; if there is a returning execution, it is the last active
+execution; and there are passive executions only if there is a returning
+execution.
 [*Note 1*: Passive executions allow other threads to reliably observe
 the results produced by the earlier returning execution. — *end note*]
 *Synchronization:* For any given `once_flag`: all active executions
 occur in a total order; completion of an active execution synchronizes
+with [[intro.multithread]] the start of the next one in this total
 order; and the returning execution synchronizes with the return from all
 passive executions.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]], or any exception thrown by `func`.
 [*Example 1*:
 ``` cpp
 // global flag, regular function

Diff to HTML by rtfpessoa