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

Files changed (1) hide show

tmp/tmpcn2rr9i_/{from.md → to.md} +457 -277

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

@@ -2,48 +2,49 @@
 This section provides mechanisms for mutual exclusion: mutexes, locks,
 and call once. These mechanisms ease the production of race-free
 programs ([[intro.multithread]]).
 ``` cpp
 namespace std {
   class mutex;
   class recursive_mutex;
   class timed_mutex;
   class recursive_timed_mutex;
-  struct defer_lock_t { };
-  struct try_to_lock_t { };
-  struct adopt_lock_t { };
-  constexpr defer_lock_t  defer_lock { };
-  constexpr try_to_lock_t try_to_lock { };
-  constexpr adopt_lock_t  adopt_lock { };
   template <class Mutex> class lock_guard;
   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 {
-    constexpr once_flag() noexcept;
-    once_flag(const once_flag&) = delete;
-    once_flag& operator=(const once_flag&) = delete;
-  };
   template<class Callable, class... Args>
     void call_once(once_flag& flag, Callable&& func, Args&&... args);
 }
 ```
 ``` cpp
 namespace std {
   class shared_timed_mutex;
   template <class Mutex> class shared_lock;
   template <class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 }
@@ -61,15 +62,15 @@ 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 `std::mutex`,
-`std::recursive_mutex`, `std::timed_mutex`,
-`std::recursive_timed_mutex`, and `std::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
@@ -82,37 +83,39 @@ 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.
-- `device_or_resource_busy` — if any native handle type manipulated is
-  already locked.
 - `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. this can be viewed as the modification order (
-[[intro.multithread]]) of the mutex. 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.
 The expression `m.lock()` shall be well-formed and have the following
 semantics:
-*Requires:* If `m` is of type `std::mutex`, `std::timed_mutex`, or
-`std::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.
-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
@@ -122,51 +125,53 @@ required ([[thread.req.exception]]).
 - `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.
-- `device_or_resource_busy` — if the mutex is already locked and
-  blocking is not possible.
 The expression `m.try_lock()` shall be well-formed and have the
 following semantics:
-*Requires:* If `m` is of type `std::mutex`, `std::timed_mutex`, or
-`std::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. This
-spurious failure is normally uncommon, but allows interesting
-implementations based on a simple compare and exchange
-(Clause  [[atomics]]). 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. 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.
 *Throws:* Nothing.
 The expression `m.unlock()` shall be well-formed and have the following
 semantics:
-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.
@@ -186,11 +191,11 @@ namespace std {
     void lock();
     bool try_lock();
     void unlock();
- typedef implementation-defined native_handle_type; // See~[thread.req.native]
     native_handle_type native_handle();                // See~[thread.req.native]
   };
 }
 ```
@@ -198,26 +203,27 @@ 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()`.
-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
 typically occur when a reference-counted object contains a mutex that is
-used to protect the reference count.
-The class `mutex` shall satisfy all the `Mutex` requirements (
 [[thread.mutex.requirements]]). It shall be a standard-layout class
 (Clause  [[class]]).
-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.
 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.
@@ -235,11 +241,11 @@ namespace std {
     void lock();
     bool try_lock() noexcept;
     void unlock();
- typedef implementation-defined native_handle_type; // See~[thread.req.native]
     native_handle_type native_handle();                // See~[thread.req.native]
   };
 }
 ```
@@ -247,13 +253,13 @@ 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 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
@@ -269,38 +275,39 @@ 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
-`std::timed_mutex`, `std::recursive_timed_mutex`, and
-`std::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:
-If `m` is of type `std::timed_mutex` or `std::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. 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.
-*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
@@ -309,23 +316,24 @@ 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 `std::timed_mutex` or
-`std::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. 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.
-*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
@@ -351,11 +359,11 @@ 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();
- typedef implementation-defined native_handle_type; // See~[thread.req.native]
     native_handle_type native_handle();                // See~[thread.req.native]
   };
 }
 ```
@@ -365,11 +373,11 @@ 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 `TimedMutex`
 requirements ([[thread.timedmutex.requirements]]). It shall be a
 standard-layout class (Clause  [[class]]).
 The behavior of a program is undefined if:
@@ -397,11 +405,11 @@ 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();
- typedef implementation-defined native_handle_type; // See~[thread.req.native]
     native_handle_type native_handle();                // See~[thread.req.native]
   };
 }
 ```
@@ -411,11 +419,11 @@ 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 `TimedMutex`
 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()`,
@@ -433,20 +441,17 @@ 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 timed mutex types <a id="thread.sharedtimedmutex.requirements">[[thread.sharedtimedmutex.requirements]]</a>
-The standard library type `std::shared_timed_mutex` is a *shared timed
-mutex type*. Shared timed mutex types shall meet the requirements of
-timed mutex types ([[thread.timedmutex.requirements]]), and
-additionally shall meet the requirements set out below. In this
-description, `m` denotes an object of a 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]]).
 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
@@ -466,28 +471,26 @@ following 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 shall not have been acquired for the current thread.
-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.
-- `device_or_resource_busy` — if the mutex is already locked and
-  blocking is not possible.
 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.
@@ -518,15 +521,71 @@ 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.
 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.
@@ -534,14 +593,17 @@ and have the following semantics:
 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. 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. 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.
@@ -560,14 +622,17 @@ and have the following semantics:
 *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. 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. 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.
@@ -614,14 +679,13 @@ namespace std {
 ```
 The class `shared_timed_mutex` provides a non-recursive mutex with
 shared ownership semantics.
-The class `shared_timed_mutex` shall satisfy all of the
-`SharedTimedMutex` 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
@@ -635,13 +699,15 @@ 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
 ownership of that lockable object for an execution agent. A lock does
-not manage the lifetime of the lockable object it references. Locks are
-intended to ease the burden of unlocking the lockable object under both
-normal and exceptional circumstances.
 Some lock constructors take tag types which describe what should be done
 with the lockable object during the lock’s construction.
 ``` cpp
@@ -650,35 +716,37 @@ namespace std {
   struct try_to_lock_t { };     // try to acquire ownership of the mutex
                                 // without blocking
   struct adopt_lock_t  { };     // assume the calling thread has already
                                 // obtained mutex ownership and manage it
-  constexpr defer_lock_t   defer_lock { };
-  constexpr try_to_lock_t  try_to_lock { };
-  constexpr adopt_lock_t   adopt_lock { };
 }
 ```
 #### Class template `lock_guard` <a id="thread.lock.guard">[[thread.lock.guard]]</a>
 ``` cpp
 namespace std {
   template <class Mutex>
   class lock_guard {
   public:
- typedef Mutex mutex_type;
     explicit lock_guard(mutex_type& m);
     lock_guard(mutex_type& m, adopt_lock_t);
     ~lock_guard();
-    lock_guard(lock_guard const&) = delete;
-    lock_guard& operator=(lock_guard const&) = 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
@@ -690,43 +758,107 @@ object referenced by `pm` does not exist for the entire lifetime of the
 ``` cpp
 explicit lock_guard(mutex_type& m);
 ```
-If `mutex_type` is not a recursive mutex, the calling thread does not
-own the mutex `m`.
-*Effects:* `m.lock()`
-`&pm == &m`
 ``` cpp
 lock_guard(mutex_type& m, adopt_lock_t);
 ```
-The calling thread owns the mutex `m`.
-`&pm == &m`
 *Throws:* Nothing.
 ``` cpp
 ~lock_guard();
 ```
-*Effects:* `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:
- typedef Mutex mutex_type;
-    // [thread.lock.unique.cons], construct/copy/destroy:
     unique_lock() noexcept;
     explicit unique_lock(mutex_type& m);
     unique_lock(mutex_type& m, defer_lock_t) noexcept;
     unique_lock(mutex_type& m, try_to_lock_t);
     unique_lock(mutex_type& m, adopt_lock_t);
@@ -734,41 +866,43 @@ namespace std {
       unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Rep, class Period>
       unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~unique_lock();
-    unique_lock(unique_lock const&) = delete;
-    unique_lock& operator=(unique_lock const&) = delete;
     unique_lock(unique_lock&& u) noexcept;
     unique_lock& operator=(unique_lock&& u);
-    // [thread.lock.unique.locking], locking:
     void lock();
     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();
-    // [thread.lock.unique.mod], modifiers:
     void swap(unique_lock& u) noexcept;
     mutex_type* release() noexcept;
-    // [thread.lock.unique.obs], observers:
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
   private:
     mutex_type* pm; // exposition only
     bool owns;      // exposition only
   };
   template <class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 }
 ```
@@ -781,15 +915,16 @@ 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]]).
-`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.
 ##### `unique_lock` constructors, destructor, and assignment <a id="thread.lock.unique.cons">[[thread.lock.unique.cons]]</a>
 ``` cpp
 unique_lock() noexcept;
@@ -801,81 +936,81 @@ unique_lock() noexcept;
 ``` cpp
 explicit unique_lock(mutex_type& m);
 ```
-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 == &m` and `owns == true`.
 ``` cpp
 unique_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
 *Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == &m` and `owns == false`.
 ``` cpp
 unique_lock(mutex_type& m, try_to_lock_t);
 ```
-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 == &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);
 ```
-The calling thread own the mutex.
 *Effects:* Constructs an object of type `unique_lock`.
-*Postconditions:* `pm == &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);
 ```
-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 == &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);
 ```
-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 == &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;
 ```
@@ -891,13 +1026,13 @@ unique_lock& operator=(unique_lock&& u);
 *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`.
-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.
 *Throws:* Nothing.
 ``` cpp
 ~unique_lock();
@@ -909,96 +1044,104 @@ mutex after the assignment and `u` will not.
 ``` cpp
 void lock();
 ```
-*Effects:* `pm->lock()`
-`owns == true`
-*Throws:* Any exception thrown by `pm->lock()`. `system_error` if an
-exception is required ([[thread.req.exception]]). `system_error` with
-an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 bool try_lock();
 ```
-The supplied `Mutex` shall meet the `Lockable`
 requirements ([[thread.req.lockable.req]]).
-*Effects:* `pm->try_lock()`
 *Returns:* The value returned by the call to `try_lock()`.
-`owns == res`, where `res` is the value returned by the call to
-`try_lock()`.
-*Throws:* Any exception thrown by `pm->try_lock()`. `system_error` if an
-exception is required ([[thread.req.exception]]). `system_error` with
-an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`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);
 ```
 *Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
 requirements ([[thread.req.lockable.timed]]).
-*Effects:* `pm->try_lock_until(abs_time)`
 *Returns:* The value returned by the call to `try_lock_until(abs_time)`.
-`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`
-if an exception is required ([[thread.req.exception]]). `system_error`
-with an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`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);
 ```
 *Requires:* The supplied `Mutex` type shall meet the `TimedLockable`
 requirements ([[thread.req.lockable.timed]]).
-*Effects:* `pm->try_lock_for(rel_time)`.
 *Returns:* The value returned by the call to `try_lock_until(rel_time)`.
-`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`
-if an exception is required ([[thread.req.exception]]). `system_error`
-with an error condition of `operation_not_permitted` if `pm` is 0.
-`system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 void unlock();
 ```
-*Effects:* `pm->unlock()`
-`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;
@@ -1017,43 +1160,42 @@ mutex_type* release() noexcept;
 ``` cpp
 template <class Mutex>
   void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 ```
-*Effects:* `x.swap(y)`
 ##### `unique_lock` observers <a id="thread.lock.unique.obs">[[thread.lock.unique.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
 ```
-*Returns:* `owns`
 ``` cpp
 explicit operator bool() const noexcept;
 ```
-*Returns:* `owns`
 ``` cpp
 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:
-  typedef Mutex mutex_type;
- // Shared locking
     shared_lock() 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);
@@ -1063,42 +1205,44 @@ public:
     template <class Rep, class Period>
       shared_lock(mutex_type& m,
                 const chrono::duration<Rep, Period>& rel_time);
     ~shared_lock();
- shared_lock(shared_lock const&) = delete;
- shared_lock& operator=(shared_lock const&) = delete;
     shared_lock(shared_lock&& u) noexcept;
     shared_lock& operator=(shared_lock&& u) noexcept;
     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();
- // Setters
     void swap(shared_lock& u) noexcept;
     mutex_type* release() noexcept;
- // Getters
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
   private:
     mutex_type* pm; // exposition only
     bool owns;      // exposition only
   };
   template <class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
-}  // std
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
 may be acquired at construction or after construction, and may be
@@ -1108,12 +1252,12 @@ 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]]).
-`shared_lock<Mutex>` meets the `TimedLockable` requirements (
-[[thread.req.lockable.timed]]).
 ##### `shared_lock` constructors, destructor, and assignment <a id="thread.lock.shared.cons">[[thread.lock.shared.cons]]</a>
 ``` cpp
 shared_lock() noexcept;
@@ -1131,19 +1275,19 @@ explicit shared_lock(mutex_type& m);
 mode.
 *Effects:* Constructs an object of type `shared_lock` and calls
 `m.lock_shared()`.
-*Postconditions:* `pm == &m` and `owns == true`.
 ``` cpp
 shared_lock(mutex_type& m, defer_lock_t) noexcept;
 ```
 *Effects:* Constructs an object of type `shared_lock`.
-*Postconditions:* `pm == &m` and `owns == false`.
 ``` cpp
 shared_lock(mutex_type& m, try_to_lock_t);
 ```
@@ -1151,22 +1295,22 @@ shared_lock(mutex_type& m, try_to_lock_t);
 mode.
 *Effects:* Constructs an object of type `shared_lock` and calls
 `m.try_lock_shared()`.
-*Postconditions:* `pm == &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 == &m` and `owns == true`.
 ``` cpp
 template <class Clock, class Duration>
   shared_lock(mutex_type& m,
               const chrono::time_point<Clock, Duration>& abs_time);
@@ -1176,12 +1320,12 @@ template <class Clock, class Duration>
 mode.
 *Effects:* Constructs an object of type `shared_lock` and calls
 `m.try_lock_shared_until(abs_time)`.
-*Postconditions:* `pm == &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);
@@ -1191,12 +1335,12 @@ template <class Rep, class Period>
 mode.
 *Effects:* Constructs an object of type `shared_lock` and calls
 `m.try_lock_shared_for(rel_time)`.
-*Postconditions:* `pm == &m` and `owns == res` where `res` is the value
-returned by the call to `m.try_lock_shared_for(rel_time)`.
 ``` cpp
 ~shared_lock();
 ```
@@ -1204,106 +1348,117 @@ 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:* `pm->lock_shared()`.
 *Postconditions:* `owns == true`.
-*Throws:* Any exception thrown by `pm->lock_shared()`. `system_error` if
-an exception is required ([[thread.req.exception]]). `system_error`
-with an error condition of `operation_not_permitted` if `pm` is
-`nullptr`. `system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 bool try_lock();
 ```
-*Effects:* `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` if an exception is required ([[thread.req.exception]]).
-`system_error` with an error condition of `operation_not_permitted` if
-`pm` is `nullptr`. `system_error` with an error condition of
-`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:* `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` if an exception is required ([[thread.req.exception]]).
-`system_error` with an error condition of `operation_not_permitted` if
-`pm` is `nullptr`. `system_error` with an error condition of
-`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);
 ```
-*Effects:* `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` if an exception is required  ([[thread.req.exception]]).
-`system_error` with an error condition of `operation_not_permitted` if
-`pm` is `nullptr`. `system_error` with an error condition of
-`resource_deadlock_would_occur` if on entry `owns` is `true`.
 ``` cpp
 void unlock();
 ```
-*Effects:* `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`.
@@ -1326,11 +1481,11 @@ mutex_type* release() noexcept;
 ``` cpp
 template <class Mutex>
   void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
 ```
-*Effects:* `x.swap(y)`.
 ##### `shared_lock` observers <a id="thread.lock.shared.obs">[[thread.lock.shared.obs]]</a>
 ``` cpp
 bool owns_lock() const noexcept;
@@ -1355,97 +1510,120 @@ 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. The `unique_lock` class template meets these requirements
-when suitably instantiated.
 *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 0-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, The `unique_lock` class template meets these requirements
-when suitably instantiated.
 *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. 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. 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>
 The class `once_flag` is an opaque data structure that `call_once` uses
 to initialize data without causing a data race or deadlock.
-#### Struct `once_flag` <a id="thread.once.onceflag">[[thread.once.onceflag]]</a>
 ``` cpp
 constexpr once_flag() noexcept;
 ```
 *Effects:* Constructs an object of type `once_flag`.
 *Synchronization:* The construction of a `once_flag` object is not
 synchronized.
-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:* `Callable` and each `Ti` in `Args` shall satisfy the
-`MoveConstructible` requirements. *`INVOKE`*`(`*`DECAY_COPY`*`(`
-`std::forward<Callable>(func)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
-([[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`*`(`*`DECAY_COPY`*`(`
-`std::forward<Callable>(func)), `*`DECAY_COPY`*`(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. passive executions allow other threads
-to reliably observe the results produced by the earlier returning
-execution.
 *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`.
 ``` cpp
 // global flag, regular function
 void init();
 std::once_flag flag;
@@ -1470,5 +1648,7 @@ class information {
 public:
   void verify() { std::call_once(verified, &information::verifier, *this); }
 };
 ```

 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 {
   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;
   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;
   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>
+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
 - `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
 - `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.
     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]
   };
 }
 ```
 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
 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.
     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]
   };
 }
 ```
 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
 - 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
 *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*]
+*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
       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]
   };
 }
 ```
 `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:
       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]
   };
 }
 ```
 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()`,
 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
 *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.
 *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();
+    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
+  `shared_mutex`, or
+- a thread terminates while possessing any ownership of a
+  `shared_mutex`.
+`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.
 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.
 *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.
 ```
 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
 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
 ownership of that lockable object for an execution agent. A lock does
+not manage the lifetime of the lockable object it references.
+[*Note 1*: Locks are intended to ease the burden of unlocking the
+lockable object under both normal and exceptional
+circumstances. — *end note*]
 Some lock constructors take tag types which describe what should be done
 with the lockable object during the lock’s construction.
 ``` cpp
   struct try_to_lock_t { };     // try to acquire ownership of the mutex
                                 // without blocking
   struct adopt_lock_t  { };     // assume the calling thread has already
                                 // obtained mutex ownership and manage it
+ inline constexpr defer_lock_t   defer_lock { };
+ inline constexpr try_to_lock_t  try_to_lock { };
+ inline constexpr adopt_lock_t   adopt_lock { };
 }
 ```
 #### Class template `lock_guard` <a id="thread.lock.guard">[[thread.lock.guard]]</a>
 ``` cpp
 namespace std {
   template <class Mutex>
   class lock_guard {
   public:
+ using mutex_type = Mutex;
     explicit lock_guard(mutex_type& m);
     lock_guard(mutex_type& m, adopt_lock_t);
     ~lock_guard();
+    lock_guard(const lock_guard&) = delete;
+    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
 ``` 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();
 ```
+*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(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.
+``` cpp
+~scoped_lock();
+```
+*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:
+ using mutex_type = Mutex;
+    // [thread.lock.unique.cons], construct/copy/destroy
     unique_lock() noexcept;
     explicit unique_lock(mutex_type& m);
     unique_lock(mutex_type& m, defer_lock_t) noexcept;
     unique_lock(mutex_type& m, try_to_lock_t);
     unique_lock(mutex_type& m, adopt_lock_t);
       unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
     template <class Rep, class Period>
       unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
     ~unique_lock();
+    unique_lock(const unique_lock&) = delete;
+    unique_lock& operator=(const unique_lock&) = delete;
     unique_lock(unique_lock&& u) noexcept;
     unique_lock& operator=(unique_lock&& u);
+    // [thread.lock.unique.locking], locking
     void lock();
     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();
+    // [thread.lock.unique.mod], modifiers
     void swap(unique_lock& u) noexcept;
     mutex_type* release() noexcept;
+    // [thread.lock.unique.obs], observers
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
   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;
 }
 ```
 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;
 ``` 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`.
+[*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*]
 *Throws:* Nothing.
 ``` cpp
 ~unique_lock();
 ``` 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`.
 ``` 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`.
 ``` 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`.
 ``` cpp
 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;
 ``` 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;
 ```
+*Returns:* `owns`.
 ``` cpp
 explicit operator bool() const noexcept;
 ```
+*Returns:* `owns`.
 ``` cpp
 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:
+    using mutex_type = Mutex;
+ // [thread.lock.shared.cons], construct/copy/destroy
     shared_lock() 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 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;
     shared_lock(shared_lock&& u) noexcept;
     shared_lock& operator=(shared_lock&& u) noexcept;
+    // [thread.lock.shared.locking], locking
     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();
+ // [thread.lock.shared.mod], modifiers
     void swap(shared_lock& u) noexcept;
     mutex_type* release() noexcept;
+ // [thread.lock.shared.obs], observers
     bool owns_lock() const noexcept;
     explicit operator bool () const noexcept;
     mutex_type* mutex() const noexcept;
   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;
+}
 ```
 An object of type `shared_lock` controls the shared ownership of a
 lockable object within a scope. Shared ownership of the lockable object
 may be acquired at construction or after construction, and may be
 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;
 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);
 ```
 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);
 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);
 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();
 ```
 ``` 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`.
 ``` cpp
 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`.
 ``` 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)`.
 *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`.
 ``` cpp
 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`.
 ``` 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;
 ``` 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>
+``` cpp
+namespace std {
+  struct once_flag {
+    constexpr once_flag() noexcept;
+    once_flag(const once_flag&) = delete;
+    once_flag& operator=(const once_flag&) = delete;
+  };
+}
+```
 The class `once_flag` is an opaque data structure that `call_once` uses
 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
 void init();
 std::once_flag flag;
 public:
   void verify() { std::call_once(verified, &information::verifier, *this); }
 };
 ```
+— *end example*]

Diff to HTML by rtfpessoa