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

Files changed (1) hide show

tmp/tmpzbk0d1oa/{from.md → to.md} +151 -129

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

@@ -1,35 +1,43 @@
 ## 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 {
   class mutex;
   class recursive_mutex;
   class timed_mutex;
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
   struct try_to_lock_t { explicit try_to_lock_t() = default; };
   struct adopt_lock_t { explicit adopt_lock_t() = default; };
   inline constexpr defer_lock_t  defer_lock { };
   inline constexpr try_to_lock_t try_to_lock { };
   inline constexpr adopt_lock_t  adopt_lock { };
   template<class Mutex> class lock_guard;
   template<class... MutexTypes> class scoped_lock;
   template<class Mutex> class unique_lock;
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
   template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
   template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
   struct once_flag;
@@ -40,12 +48,15 @@ namespace std {
 ### Header `<shared_mutex>` synopsis <a id="shared.mutex.syn">[[shared.mutex.syn]]</a>
 ``` cpp
 namespace std {
   class shared_mutex;
   class shared_timed_mutex;
   template<class Mutex> class shared_lock;
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
@@ -62,18 +73,20 @@ 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.
@@ -91,15 +104,15 @@ functions of the mutex types are as follows:
 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:
@@ -109,17 +122,17 @@ semantics:
 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:*
@@ -145,24 +158,23 @@ 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:
@@ -204,11 +216,11 @@ The class `mutex` provides a non-recursive mutex with exclusive
 ownership semantics. If one thread owns a mutex object, attempts by
 another thread to acquire ownership of that object will fail (for
 `try_lock()`) or block (for `lock()`) until the owning thread has
 released ownership with a call to `unlock()`.
-[*Note 3*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
 `A` appears to have returned from its unlock call. Implementations are
 required to handle such scenarios correctly, as long as thread `A`
 doesn’t access the mutex after the unlock call returns. These cases
@@ -217,11 +229,11 @@ 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
@@ -276,19 +288,21 @@ 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
@@ -304,18 +318,18 @@ 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:
@@ -330,18 +344,18 @@ before the absolute timeout [[thread.req.timing]] specified by
 [*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*]
-*Return type:* `bool`.
-*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
@@ -444,16 +458,21 @@ 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
@@ -472,17 +491,17 @@ semantics:
 *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:*
@@ -516,19 +535,18 @@ following semantics:
 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
 other thread.
-*Return type:* `bool`.
-*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
@@ -574,19 +592,25 @@ 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 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.
@@ -603,18 +627,18 @@ 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:
@@ -632,18 +656,18 @@ 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
@@ -692,10 +716,12 @@ The behavior of a program is undefined if:
 - a thread terminates while possessing any ownership of a
   `shared_timed_mutex`.
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
 managing ownership of a lockable object in an exception safe manner. A
 lock is said to *own* a lockable object if it is currently managing the
@@ -755,39 +781,36 @@ object referenced by `pm` does not exist for the entire lifetime of the
 ``` 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();
 ```
-*Effects:* As if by `pm.unlock()`.
 #### Class template `scoped_lock` <a id="thread.lock.scoped">[[thread.lock.scoped]]</a>
 ``` cpp
 namespace std {
   template<class... MutexTypes>
   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();
@@ -803,32 +826,35 @@ namespace std {
 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.
@@ -839,10 +865,12 @@ explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
 *Effects:* For all `i` in \[`0`, `sizeof...(MutexTypes)`),
 `get<i>(pm).unlock()`.
 #### Class template `unique_lock` <a id="thread.lock.unique">[[thread.lock.unique]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class unique_lock {
   public:
@@ -888,13 +916,10 @@ namespace std {
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
-  template<class Mutex>
-    void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
 An object of type `unique_lock` controls the ownership of a lockable
 object within a scope. Ownership of the lockable object may be acquired
@@ -918,19 +943,16 @@ meets the *Cpp17TimedLockable* requirements. — *end note*]
 ``` 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
@@ -942,35 +964,33 @@ unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ``` 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
@@ -979,12 +999,11 @@ 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
@@ -1045,14 +1064,14 @@ 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:*
@@ -1068,17 +1087,17 @@ template<class Clock, class Duration>
 *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`.
@@ -1091,17 +1110,17 @@ template<class Rep, class Period>
 *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`.
@@ -1131,14 +1150,14 @@ void swap(unique_lock& u) noexcept;
 ``` cpp
 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;
 ```
@@ -1164,10 +1183,12 @@ mutex_type *mutex() const noexcept;
 *Returns:* `pm`.
 #### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class shared_lock {
   public:
@@ -1211,13 +1232,10 @@ namespace std {
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
-  template<class Mutex>
-    void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
@@ -1225,15 +1243,19 @@ 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;
@@ -1243,13 +1265,10 @@ shared_lock() noexcept;
 ``` 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
@@ -1260,34 +1279,31 @@ shared_lock(mutex_type& m, defer_lock_t) noexcept;
 ``` 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)`.
@@ -1296,12 +1312,12 @@ value returned by the call to `m.try_lock_shared_until(abs_time)`.
 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)`.
@@ -1352,15 +1368,15 @@ when an exception is required [[thread.req.exception]].
 bool try_lock();
 ```
 *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:*
@@ -1370,18 +1386,21 @@ to `pm->try_lock_shared()`.
 ``` 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:*
@@ -1391,18 +1410,21 @@ to `pm->try_lock_shared_until(abs_time)`.
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
 *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:*
@@ -1434,14 +1456,14 @@ void swap(shared_lock& sl) noexcept;
 ``` cpp
 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;
 ```
@@ -1501,11 +1523,11 @@ 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
@@ -1550,18 +1572,18 @@ template<class Callable, class... 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

 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
+### General <a id="thread.mutex.general">[[thread.mutex.general]]</a>
+Subclause [[thread.mutex]] 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 {
+  // [thread.mutex.class], class mutex
   class mutex;
+  // [thread.mutex.recursive], class recursive_mutex
   class recursive_mutex;
+  // [thread.timedmutex.class] class timed_mutex
   class timed_mutex;
+  // [thread.timedmutex.recursive], class recursive_timed_mutex
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
   struct try_to_lock_t { explicit try_to_lock_t() = default; };
   struct adopt_lock_t { explicit adopt_lock_t() = default; };
   inline constexpr defer_lock_t  defer_lock { };
   inline constexpr try_to_lock_t try_to_lock { };
   inline constexpr adopt_lock_t  adopt_lock { };
+  // [thread.lock], locks
   template<class Mutex> class lock_guard;
   template<class... MutexTypes> class scoped_lock;
   template<class Mutex> class unique_lock;
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
+  // [thread.lock.algorithm], generic locking algorithms
   template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
   template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
   struct once_flag;
 ### Header `<shared_mutex>` synopsis <a id="shared.mutex.syn">[[shared.mutex.syn]]</a>
 ``` cpp
 namespace std {
+  // [thread.sharedmutex.class], class shared_mutex
   class shared_mutex;
+  // [thread.sharedtimedmutex.class], class shared_timed_mutex
   class shared_timed_mutex;
+  // [thread.lock.shared], class template shared_lock
   template<class Mutex> class shared_lock;
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
 ```
 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>
+##### General <a id="thread.mutex.requirements.mutex.general">[[thread.mutex.requirements.mutex.general]]</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 [[thread.mutex.requirements.mutex]]. In this description, `m`
+denotes an object of a mutex type.
+[*Note 1*: The mutex types meet the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]]. — *end note*]
 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 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 2*: This can be viewed as the modification order
 [[intro.multithread]] of the mutex. — *end note*]
+[*Note 3*: Construction and destruction of an object of a mutex type
+need not be thread-safe; other synchronization can 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:
 the mutex.
 *Effects:* Blocks the calling thread until ownership of the mutex can be
 obtained for the calling thread.
 *Synchronization:* Prior `unlock()` operations on the same object
 *synchronize with*[[intro.multithread]] this operation.
+*Ensures:* The calling thread owns the mutex.
+*Return type:* `void`.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:*
 exchange [[atomics]]. — *end note*]
 An implementation should ensure that `try_lock()` does not consistently
 return `false` in the absence of contending mutex acquisitions.
 *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*]
+*Return type:* `bool`.
+*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Throws:* Nothing.
 The expression `m.unlock()` is well-formed and has the following
 semantics:
 ownership semantics. If one thread owns a mutex object, attempts by
 another thread to acquire ownership of that object will fail (for
 `try_lock()`) or block (for `lock()`) until the owning thread has
 released ownership with a call to `unlock()`.
+[*Note 4*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
 `A` appears to have returned from its unlock call. Implementations are
 required to handle such scenarios correctly, as long as thread `A`
 doesn’t access the mutex after the unlock call returns. These cases
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
 [[class.prop]].
+[*Note 5*: 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
 - 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>
+##### General <a id="thread.timedmutex.requirements.general">[[thread.timedmutex.requirements.general]]</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]].
+[*Note 1*: The timed mutex types meet the *Cpp17TimedLockable*
+requirements [[thread.req.lockable.timed]]. — *end note*]
 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
 [*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*]
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
 operations on the same object *synchronize with*[[intro.multithread]]
 this operation.
+*Return type:* `bool`.
+*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 The expression `m.try_lock_until(abs_time)` is well-formed and has the
 following semantics:
 [*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*]
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
 with*[[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if ownership was obtained, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
 - 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>
+##### General <a id="thread.sharedmutex.requirements.general">[[thread.sharedmutex.requirements.general]]</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.
+[*Note 1*: The shared mutex types meet the *Cpp17SharedLockable*
+requirements [[thread.req.lockable.shared]]. — *end note*]
 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
 *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.
 *Synchronization:* Prior `unlock()` operations on the same object
 synchronize with [[intro.multithread]] this operation.
+*Ensures:* The calling thread has a shared lock on the mutex.
+*Return type:* `void`.
 *Throws:* `system_error` when an exception is
 required [[thread.req.exception]].
 *Error conditions:*
 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
 other thread.
 *Synchronization:* If `try_lock_shared()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if the shared lock was acquired, otherwise `false`.
 *Throws:* Nothing.
 ##### Class `shared_mutex` <a id="thread.sharedmutex.class">[[thread.sharedmutex.class]]</a>
 ``` cpp
 `shared_mutex` may be a synonym for `shared_timed_mutex`.
 #### Shared timed mutex types <a id="thread.sharedtimedmutex.requirements">[[thread.sharedtimedmutex.requirements]]</a>
+##### General <a id="thread.sharedtimedmutex.requirements.general">[[thread.sharedtimedmutex.requirements.general]]</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_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]].
+[*Note 1*: The shared timed mutex types meet the
+*Cpp17SharedTimedLockable* requirements
+[[thread.req.lockable.shared.timed]]. — *end note*]
 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.
 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.
 *Synchronization:* If `try_lock_shared_for()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if the shared lock was acquired, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 The expression `m.try_lock_shared_until(abs_time)` is well-formed and
 has the following semantics:
 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.
 *Synchronization:* If `try_lock_shared_until()` returns `true`, prior
 `unlock()` operations on the same object synchronize
 with [[intro.multithread]] this operation.
+*Return type:* `bool`.
+*Returns:* `true` if the shared lock was acquired, otherwise `false`.
 *Throws:* Timeout-related exceptions [[thread.req.timing]].
 ##### Class `shared_timed_mutex` <a id="thread.sharedtimedmutex.class">[[thread.sharedtimedmutex.class]]</a>
 ``` cpp
 - a thread terminates while possessing any ownership of a
   `shared_timed_mutex`.
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
+#### General <a id="thread.lock.general">[[thread.lock.general]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
 managing ownership of a lockable object in an exception safe manner. A
 lock is said to *own* a lockable object if it is currently managing the
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
 *Effects:* Initializes `pm` with `m`. Calls `m.lock()`.
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
+*Preconditions:* The calling thread holds a non-shared lock on `m`.
 *Effects:* Initializes `pm` with `m`.
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
 ```
+*Effects:* Equivalent to: `pm.unlock()`
 #### Class template `scoped_lock` <a id="thread.lock.scoped">[[thread.lock.scoped]]</a>
 ``` cpp
 namespace std {
   template<class... MutexTypes>
   class scoped_lock {
   public:
+    using mutex_type = see below; // Only if sizeof...(MutexTypes) == 1 is true
     explicit scoped_lock(MutexTypes&... m);
     explicit scoped_lock(adopt_lock_t, MutexTypes&... m);
     ~scoped_lock();
 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.
+- If `sizeof...(MutexTypes)` is one, let `Mutex` denote the sole type
+  constituting the pack `MutexTypes`. `Mutex` shall meet the
+  *Cpp17BasicLockable* requirements [[thread.req.lockable.basic]]. The
+  member *typedef-name* `mutex_type` denotes the same type as `Mutex`.
+- Otherwise, all types in the template parameter pack `MutexTypes` shall
+  meet the *Cpp17Lockable* requirements [[thread.req.lockable.req]] and
+  there is no member `mutex_type`.
 ``` cpp
 explicit scoped_lock(MutexTypes&... 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 holds a non-shared lock on each
+element of `m`.
 *Effects:* Initializes `pm` with `tie(m...)`.
 *Throws:* Nothing.
 *Effects:* For all `i` in \[`0`, `sizeof...(MutexTypes)`),
 `get<i>(pm).unlock()`.
 #### Class template `unique_lock` <a id="thread.lock.unique">[[thread.lock.unique]]</a>
+##### General <a id="thread.lock.unique.general">[[thread.lock.unique.general]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class unique_lock {
   public:
   private:
     mutex_type* pm;             // exposition only
     bool owns;                  // exposition only
   };
 }
 ```
 An object of type `unique_lock` controls the ownership of a lockable
 object within a scope. Ownership of the lockable object may be acquired
 ``` cpp
 unique_lock() noexcept;
 ```
+*Ensures:* `pm == nullptr` and `owns == false`.
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
 *Effects:* Calls `m.lock()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
 *Preconditions:* The supplied `Mutex` type meets the *Cpp17Lockable*
+requirements [[thread.req.lockable.req]].
 *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 holds a non-shared lock on `m`.
 *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:* 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
 ``` cpp
 template<class Rep, class Period>
   unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* 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
 *Preconditions:* The supplied `Mutex` meets the *Cpp17Lockable*
 requirements [[thread.req.lockable.req]].
 *Effects:* As if by `pm->try_lock()`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock()`.
+*Returns:* The value returned by `pm->try_lock()`.
 *Throws:* Any exception thrown by `pm->try_lock()`. `system_error` when
 an exception is required [[thread.req.exception]].
 *Error conditions:*
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_until(abs_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock_until(abs_time)`.
+*Returns:* The value returned by `pm->try_lock_until(abs_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_until(abstime)`.
+`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`.
 *Preconditions:* The supplied `Mutex` type meets the
 *Cpp17TimedLockable* requirements [[thread.req.lockable.timed]].
 *Effects:* As if by `pm->try_lock_for(rel_time)`.
+*Ensures:* `owns == res`, where `res` is the value returned by
+`pm->try_lock_for(rel_time)`.
+*Returns:* The value returned by `pm->try_lock_for(rel_time)`.
+*Throws:* Any exception thrown by `pm->try_lock_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`.
 ``` cpp
 mutex_type* release() noexcept;
 ```
 *Ensures:* `pm == 0` and `owns == false`.
+*Returns:* The previous value of `pm`.
 ``` cpp
 template<class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
 *Returns:* `pm`.
 #### Class template `shared_lock` <a id="thread.lock.shared">[[thread.lock.shared]]</a>
+##### General <a id="thread.lock.shared.general">[[thread.lock.shared.general]]</a>
 ``` cpp
 namespace std {
   template<class Mutex>
   class shared_lock {
   public:
   private:
     mutex_type* pm;                             // exposition only
     bool owns;                                  // exposition only
   };
 }
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
 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 *Cpp17SharedLockable* requirements
+[[thread.req.lockable.shared]].
+[*Note 1*: `shared_lock<Mutex>` meets the *Cpp17Lockable* requirements
+[[thread.req.lockable.req]]. If `Mutex` meets the
+*Cpp17SharedTimedLockable* requirements
+[[thread.req.lockable.shared.timed]], `shared_lock<Mutex>` also 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;
 ``` cpp
 explicit shared_lock(mutex_type& m);
 ```
 *Effects:* Calls `m.lock_shared()`.
 *Ensures:* `pm == addressof(m)` and `owns == true`.
 ``` cpp
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
 *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 holds a shared lock on `m`.
 *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:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *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)`.
 template<class Rep, class Period>
   shared_lock(mutex_type& m,
               const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *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)`.
 bool try_lock();
 ```
 *Effects:* As if by `pm->try_lock_shared()`.
 *Ensures:* `owns == res`, where `res` is the value returned by the call
 to `pm->try_lock_shared()`.
+*Returns:* 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:*
 ``` cpp
 template<class Clock, class Duration>
   bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* As if by `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)`.
+*Returns:* 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:*
 ``` cpp
 template<class Rep, class Period>
   bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `Mutex` meets the *Cpp17SharedTimedLockable*
+requirements [[thread.req.lockable.shared.timed]].
 *Effects:* As if by `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)`.
+*Returns:* 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:*
 ``` cpp
 mutex_type* release() noexcept;
 ```
 *Ensures:* `pm == nullptr` and `owns == false`.
+*Returns:* The previous value of `pm`.
 ``` cpp
 template<class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```
 *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 can
 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
 *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)...) [[func.require]]. 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

Diff to HTML by rtfpessoa