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

Files changed (1) hide show

tmp/tmpvfva0qxl/{from.md → to.md} +225 -134

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

@@ -4,13 +4,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
@@ -19,35 +21,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
@@ -59,43 +63,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);
@@ -103,41 +171,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;
 }
 ```
@@ -150,15 +220,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;
@@ -170,81 +241,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;
 ```
@@ -260,13 +331,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();
@@ -278,96 +349,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;
@@ -386,43 +465,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);
@@ -432,42 +510,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
@@ -477,12 +557,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;
@@ -500,19 +580,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);
 ```
@@ -520,22 +600,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);
@@ -545,12 +625,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);
@@ -560,12 +640,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();
 ```
@@ -573,106 +653,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`.
@@ -695,11 +786,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;

 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;

Diff to HTML by rtfpessoa