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

Files changed (1) hide show

tmp/tmpxrlb0i7j/{from.md → to.md} +191 -105

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

@@ -2,35 +2,35 @@
 Condition variables provide synchronization primitives used to block a
 thread until notified by some other thread that some condition is met or
 until a system time is reached. Class `condition_variable` provides a
 condition variable that can only wait on an object of type
-`unique_lock<mutex>`, allowing maximum efficiency on some platforms.
 Class `condition_variable_any` provides a general condition variable
 that can wait on objects of user-supplied lock types.
 Condition variables permit concurrent invocation of the `wait`,
 `wait_for`, `wait_until`, `notify_one` and `notify_all` member
 functions.
-The execution of `notify_one` and `notify_all` shall be atomic. The
-execution of `wait`, `wait_for`, and `wait_until` shall be performed in
 three atomic parts:
 1.  the release of the mutex and entry into the waiting state;
 2.  the unblocking of the wait; and
 3.  the reacquisition of the lock.
-The implementation shall behave as if all executions of `notify_one`,
 `notify_all`, and each part of the `wait`, `wait_for`, and `wait_until`
 executions are executed in a single unspecified total order consistent
 with the "happens before" order.
 Condition variable construction and destruction need not be
 synchronized.
-### Header `<condition_variable>` synopsis <a id="condition_variable.syn">[[condition_variable.syn]]</a>
 ``` cpp
 namespace std {
   class condition_variable;
   class condition_variable_any;
@@ -45,22 +45,22 @@ namespace std {
 ``` cpp
 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 ```
-*Requires:* `lk` is locked by the calling thread and either
 - no other thread is waiting on `cond`, or
 - `lk.mutex()` returns the same value for each of the lock arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 *Effects:* Transfers ownership of the lock associated with `lk` into
 internal storage and schedules `cond` to be notified when the current
 thread exits, after all objects of thread storage duration associated
-with the current thread have been destroyed. This notification shall be
-as if:
 ``` cpp
 lk.unlock();
 cond.notify_all();
 ```
@@ -68,11 +68,11 @@ cond.notify_all();
 *Synchronization:* The implied `lk.unlock()` call is sequenced after the
 destruction of all objects with thread storage duration associated with
 the current thread.
 [*Note 1*: The supplied lock will be held until the thread exits, and
-care must be taken to ensure that this does not cause deadlock due to
 lock ordering issues. After calling `notify_all_at_thread_exit` it is
 recommended that the thread should be exited as soon as possible, and
 that no blocking or time-consuming tasks are run on that
 thread. — *end note*]
@@ -87,11 +87,10 @@ this lock is not released and reacquired prior to calling
 ``` cpp
 namespace std {
   class condition_variable {
   public:
     condition_variable();
     ~condition_variable();
     condition_variable(const condition_variable&) = delete;
     condition_variable& operator=(const condition_variable&) = delete;
@@ -106,60 +105,55 @@ namespace std {
                            const chrono::time_point<Clock, Duration>& abs_time);
     template<class Clock, class Duration, class Predicate>
       bool wait_until(unique_lock<mutex>& lock,
                       const chrono::time_point<Clock, Duration>& abs_time,
                       Predicate pred);
     template<class Rep, class Period>
       cv_status wait_for(unique_lock<mutex>& lock,
                          const chrono::duration<Rep, Period>& rel_time);
     template<class Rep, class Period, class Predicate>
       bool wait_for(unique_lock<mutex>& lock,
                     const chrono::duration<Rep, Period>& rel_time,
                     Predicate pred);
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    native_handle_type native_handle(); // See~[thread.req.native]
   };
 }
 ```
-The class `condition_variable` shall be a standard-layout class (Clause
-[[class]]).
 ``` cpp
 condition_variable();
 ```
-*Effects:* Constructs an object of type `condition_variable`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `resource_unavailable_try_again` — if some non-memory resource
   limitation prevents initialization.
 ``` cpp
 ~condition_variable();
 ```
-*Requires:* There shall be no thread blocked on `*this`.
-[*Note 1*: That is, all threads shall have been notified; they may
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
-destruction. Only the notification to unblock the wait must happen
-before destruction. The user must take care to ensure that no threads
 wait on `*this` once the destructor has been started, especially when
 the waiting threads are calling the wait functions in a loop or using
 the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
-*Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
 ```
 *Effects:* If any threads are blocked waiting for `*this`, unblocks one
@@ -173,12 +167,12 @@ void notify_all() noexcept;
 ``` cpp
 void wait(unique_lock<mutex>& lock);
 ```
-*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -190,27 +184,27 @@ the calling thread, and either
   then returns.
 - The function will unblock when signaled by a call to `notify_one()` or
   a call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
 [*Note 2*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
-locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template<class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
-*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -221,28 +215,28 @@ the calling thread, and either
 while (!pred())
   wait(lock);
 ```
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
 [*Note 3*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
-locked by the calling thread.
 *Throws:* Any exception thrown by `pred`.
 ``` cpp
 template<class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
 ```
-*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -252,38 +246,37 @@ the calling thread, and either
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock),
   then returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, expiration of the absolute
-  timeout ([[thread.req.timing]]) specified by `abs_time`, or
-  spuriously.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
 [*Note 4*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
-locked by the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
-timeout ([[thread.req.timing]]) specified by `abs_time` expired,
-otherwise `cv_status::no_timeout`.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template<class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
-*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -293,33 +286,33 @@ the calling thread, and either
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
-timeout ([[thread.req.timing]]) specified by `rel_time` expired,
-otherwise `cv_status::no_timeout`.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
 [*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
-locked by the calling thread.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template<class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);
 ```
-*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -332,34 +325,34 @@ while (!pred())
     return pred();
 return true;
 ```
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
 [*Note 6*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
-locked by the calling thread.
 [*Note 7*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]) or any
 exception thrown by `pred`.
 ``` cpp
 template<class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
 ```
-*Requires:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
-the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
@@ -372,34 +365,34 @@ return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred))
 [*Note 8*: There is no blocking if `pred()` is initially `true`, even
 if the timeout has already expired. — *end note*]
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
 [*Note 9*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
-locked by the calling thread.
 [*Note 10*: The returned value indicates whether the predicate
 evaluates to `true` regardless of whether the timeout was
 triggered. — *end note*]
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]) or any
 exception thrown by `pred`.
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
-A `Lock` type shall meet the `BasicLockable` requirements (
-[[thread.req.lockable.basic]]).
 [*Note 1*: All of the standard mutex types meet this requirement. If a
 `Lock` type other than one of the standard mutex types or a
 `unique_lock` wrapper for a standard mutex type is used with
-`condition_variable_any`, the user must ensure that any necessary
 synchronization is in place with respect to the predicate associated
 with the `condition_variable_any` instance. — *end note*]
 ``` cpp
 namespace std {
@@ -411,10 +404,12 @@ namespace std {
     condition_variable_any(const condition_variable_any&) = delete;
     condition_variable_any& operator=(const condition_variable_any&) = delete;
     void notify_one() noexcept;
     void notify_all() noexcept;
     template<class Lock>
       void wait(Lock& lock);
     template<class Lock, class Predicate>
       void wait(Lock& lock, Predicate pred);
@@ -424,24 +419,31 @@ namespace std {
       bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time,
                       Predicate pred);
     template<class Lock, class Rep, class Period>
       cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
     template<class Lock, class Rep, class Period, class Predicate>
-      bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time,
-        Predicate pred);
   };
 }
 ```
 ``` cpp
 condition_variable_any();
 ```
-*Effects:* Constructs an object of type `condition_variable_any`.
 *Throws:* `bad_alloc` or `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `resource_unavailable_try_again` — if some non-memory resource
   limitation prevents initialization.
@@ -450,24 +452,22 @@ required ([[thread.req.exception]]).
 ``` cpp
 ~condition_variable_any();
 ```
-*Requires:* There shall be no thread blocked on `*this`.
-[*Note 1*: That is, all threads shall have been notified; they may
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
-destruction. Only the notification to unblock the wait must happen
-before destruction. The user must take care to ensure that no threads
 wait on `*this` once the destructor has been started, especially when
 the waiting threads are calling the wait functions in a loop or using
 the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
-*Effects:* Destroys the object.
 ``` cpp
 void notify_one() noexcept;
 ```
 *Effects:* If any threads are blocked waiting for `*this`, unblocks one
@@ -477,34 +477,32 @@ of those threads.
 void notify_all() noexcept;
 ```
 *Effects:* Unblocks all threads that are blocked waiting for `*this`.
 ``` cpp
 template<class Lock>
   void wait(Lock& lock);
 ```
-[*Note 2*: If any of the `wait` functions exits via an exception, it is
-unspecified whether the `Lock` is held. One can use a `Lock` type that
-allows to query that, such as the `unique_lock` wrapper. — *end note*]
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
-[*Note 3*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock` is locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template<class Lock, class Predicate>
@@ -528,28 +526,27 @@ template <class Lock, class Clock, class Duration>
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, expiration of the absolute
-  timeout ([[thread.req.timing]]) specified by `abs_time`, or
-  spuriously.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
-[*Note 4*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock` is locked by the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
-timeout ([[thread.req.timing]]) specified by `abs_time` expired,
-otherwise `cv_status::no_timeout`.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template<class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
@@ -559,22 +556,22 @@ template <class Lock, class Rep, class Period>
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
-timeout ([[thread.req.timing]]) specified by `rel_time` expired,
-otherwise `cv_status::no_timeout`.
 *Remarks:* If the function fails to meet the postcondition,
-`terminate()` shall be called ([[except.terminate]]).
-[*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
-*Postconditions:* `lock` is locked by the calling thread.
-*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template<class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
@@ -586,14 +583,14 @@ while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-[*Note 6*: There is no blocking if `pred()` is initially `true`, or if
 the timeout has already expired. — *end note*]
-[*Note 7*: The returned value indicates whether the predicate evaluates
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
 ``` cpp
 template<class Lock, class Rep, class Period, class Predicate>
@@ -604,5 +601,94 @@ template <class Lock, class Rep, class Period, class Predicate>
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```

 Condition variables provide synchronization primitives used to block a
 thread until notified by some other thread that some condition is met or
 until a system time is reached. Class `condition_variable` provides a
 condition variable that can only wait on an object of type
+`unique_lock<mutex>`, allowing the implementation to be more efficient.
 Class `condition_variable_any` provides a general condition variable
 that can wait on objects of user-supplied lock types.
 Condition variables permit concurrent invocation of the `wait`,
 `wait_for`, `wait_until`, `notify_one` and `notify_all` member
 functions.
+The executions of `notify_one` and `notify_all` are atomic. The
+executions of `wait`, `wait_for`, and `wait_until` are performed in
 three atomic parts:
 1.  the release of the mutex and entry into the waiting state;
 2.  the unblocking of the wait; and
 3.  the reacquisition of the lock.
+The implementation behaves as if all executions of `notify_one`,
 `notify_all`, and each part of the `wait`, `wait_for`, and `wait_until`
 executions are executed in a single unspecified total order consistent
 with the "happens before" order.
 Condition variable construction and destruction need not be
 synchronized.
+### Header `<condition_variable>` synopsis <a id="condition.variable.syn">[[condition.variable.syn]]</a>
 ``` cpp
 namespace std {
   class condition_variable;
   class condition_variable_any;
 ``` cpp
 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 ```
+*Preconditions:* `lk` is locked by the calling thread and either
 - no other thread is waiting on `cond`, or
 - `lk.mutex()` returns the same value for each of the lock arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 *Effects:* Transfers ownership of the lock associated with `lk` into
 internal storage and schedules `cond` to be notified when the current
 thread exits, after all objects of thread storage duration associated
+with the current thread have been destroyed. This notification is
+equivalent to:
 ``` cpp
 lk.unlock();
 cond.notify_all();
 ```
 *Synchronization:* The implied `lk.unlock()` call is sequenced after the
 destruction of all objects with thread storage duration associated with
 the current thread.
 [*Note 1*: The supplied lock will be held until the thread exits, and
+care should be taken to ensure that this does not cause deadlock due to
 lock ordering issues. After calling `notify_all_at_thread_exit` it is
 recommended that the thread should be exited as soon as possible, and
 that no blocking or time-consuming tasks are run on that
 thread. — *end note*]
 ``` cpp
 namespace std {
   class condition_variable {
   public:
     condition_variable();
     ~condition_variable();
     condition_variable(const condition_variable&) = delete;
     condition_variable& operator=(const condition_variable&) = delete;
                            const chrono::time_point<Clock, Duration>& abs_time);
     template<class Clock, class Duration, class Predicate>
       bool wait_until(unique_lock<mutex>& lock,
                       const chrono::time_point<Clock, Duration>& abs_time,
                       Predicate pred);
     template<class Rep, class Period>
       cv_status wait_for(unique_lock<mutex>& lock,
                          const chrono::duration<Rep, Period>& rel_time);
     template<class Rep, class Period, class Predicate>
       bool wait_for(unique_lock<mutex>& lock,
                     const chrono::duration<Rep, Period>& rel_time,
                     Predicate pred);
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    native_handle_type native_handle(); // see~[thread.req.native]
   };
 }
 ```
+The class `condition_variable` is a standard-layout class
+[[class.prop]].
 ``` cpp
 condition_variable();
 ```
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `resource_unavailable_try_again` — if some non-memory resource
   limitation prevents initialization.
 ``` cpp
 ~condition_variable();
 ```
+*Preconditions:* There is no thread blocked on `*this`.
+[*Note 1*: That is, all threads have been notified; they could
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
+destruction. Only the notification to unblock the wait needs to happen
+before destruction. The user should take care to ensure that no threads
 wait on `*this` once the destructor has been started, especially when
 the waiting threads are calling the wait functions in a loop or using
 the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
 *Effects:* If any threads are blocked waiting for `*this`, unblocks one
 ``` cpp
 void wait(unique_lock<mutex>& lock);
 ```
+*Preconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
   then returns.
 - The function will unblock when signaled by a call to `notify_one()` or
   a call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
 [*Note 2*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template<class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
+*Preconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 while (!pred())
   wait(lock);
 ```
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
 [*Note 3*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 *Throws:* Any exception thrown by `pred`.
 ``` cpp
 template<class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
 ```
+*Preconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock),
   then returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, expiration of the absolute
+  timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
+- If the function exits via an exception, `lock.lock()` is called prior
+  to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
 [*Note 4*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
+timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
+`cv_status::no_timeout`.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
 ```
+*Preconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
+timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
+`cv_status::no_timeout`.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
 [*Note 5*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
                   Predicate pred);
 ```
+*Preconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
     return pred();
 return true;
 ```
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
 [*Note 6*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 [*Note 7*: The returned value indicates whether the predicate evaluated
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
+*Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
 ``` cpp
 template<class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
                 Predicate pred);
 ```
+*Preconditions:* `lock.owns_lock()` is `true` and `lock.mutex()` is
+locked by the calling thread, and either
 - no other thread is waiting on this `condition_variable` object or
 - `lock.mutex()` returns the same value for each of the `lock` arguments
   supplied by all concurrently waiting (via `wait`, `wait_for`, or
   `wait_until`) threads.
 [*Note 8*: There is no blocking if `pred()` is initially `true`, even
 if the timeout has already expired. — *end note*]
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
 [*Note 9*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock.owns_lock()` is `true` and `lock.mutex()` is locked by
+the calling thread.
 [*Note 10*: The returned value indicates whether the predicate
 evaluates to `true` regardless of whether the timeout was
 triggered. — *end note*]
+*Throws:* Timeout-related exceptions [[thread.req.timing]] or any
 exception thrown by `pred`.
 ### Class `condition_variable_any` <a id="thread.condition.condvarany">[[thread.condition.condvarany]]</a>
+A `Lock` type shall meet the *Cpp17BasicLockable* requirements
+[[thread.req.lockable.basic]].
 [*Note 1*: All of the standard mutex types meet this requirement. If a
 `Lock` type other than one of the standard mutex types or a
 `unique_lock` wrapper for a standard mutex type is used with
+`condition_variable_any`, the user should ensure that any necessary
 synchronization is in place with respect to the predicate associated
 with the `condition_variable_any` instance. — *end note*]
 ``` cpp
 namespace std {
     condition_variable_any(const condition_variable_any&) = delete;
     condition_variable_any& operator=(const condition_variable_any&) = delete;
     void notify_one() noexcept;
     void notify_all() noexcept;
+    // [thread.condvarany.wait], noninterruptible waits
     template<class Lock>
       void wait(Lock& lock);
     template<class Lock, class Predicate>
       void wait(Lock& lock, Predicate pred);
       bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time,
                       Predicate pred);
     template<class Lock, class Rep, class Period>
       cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
     template<class Lock, class Rep, class Period, class Predicate>
+      bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
+    // [thread.condvarany.intwait], interruptible waits
+    template<class Lock, class Predicate>
+      bool wait(Lock& lock, stop_token stoken, Predicate pred);
+    template<class Lock, class Clock, class Duration, class Predicate>
+      bool wait_until(Lock& lock, stop_token stoken,
+                      const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
+    template<class Lock, class Rep, class Period, class Predicate>
+      bool wait_for(Lock& lock, stop_token stoken,
+                    const chrono::duration<Rep, Period>& rel_time, Predicate pred);
   };
 }
 ```
 ``` cpp
 condition_variable_any();
 ```
 *Throws:* `bad_alloc` or `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `resource_unavailable_try_again` — if some non-memory resource
   limitation prevents initialization.
 ``` cpp
 ~condition_variable_any();
 ```
+*Preconditions:* There is no thread blocked on `*this`.
+[*Note 1*: That is, all threads have been notified; they could
 subsequently block on the lock specified in the wait. This relaxes the
 usual rules, which would have required all wait calls to happen before
+destruction. Only the notification to unblock the wait needs to happen
+before destruction. The user should take care to ensure that no threads
 wait on `*this` once the destructor has been started, especially when
 the waiting threads are calling the wait functions in a loop or using
 the overloads of `wait`, `wait_for`, or `wait_until` that take a
 predicate. — *end note*]
 ``` cpp
 void notify_one() noexcept;
 ```
 *Effects:* If any threads are blocked waiting for `*this`, unblocks one
 void notify_all() noexcept;
 ```
 *Effects:* Unblocks all threads that are blocked waiting for `*this`.
+#### Noninterruptible waits <a id="thread.condvarany.wait">[[thread.condvarany.wait]]</a>
 ``` cpp
 template<class Lock>
   void wait(Lock& lock);
 ```
 *Effects:*
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, or spuriously.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
+[*Note 1*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock` is locked by the calling thread.
 *Throws:* Nothing.
 ``` cpp
 template<class Lock, class Predicate>
 - Atomically calls `lock.unlock()` and blocks on `*this`.
 - When unblocked, calls `lock.lock()` (possibly blocking on the lock)
   and returns.
 - The function will unblock when signaled by a call to `notify_one()`, a
   call to `notify_all()`, expiration of the absolute
+  timeout [[thread.req.timing]] specified by `abs_time`, or spuriously.
+- If the function exits via an exception, `lock.lock()` is called prior
+  to exiting the function.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
+[*Note 2*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock` is locked by the calling thread.
 *Returns:* `cv_status::timeout` if the absolute
+timeout [[thread.req.timing]] specified by `abs_time` expired, otherwise
+`cv_status::no_timeout`.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time);
 ```
 *Returns:* `cv_status::timeout` if the relative
+timeout [[thread.req.timing]] specified by `rel_time` expired, otherwise
+`cv_status::no_timeout`.
 *Remarks:* If the function fails to meet the postcondition,
+`terminate()` is called [[except.terminate]].
+[*Note 3*: This can happen if the re-locking of the mutex throws an
 exception. — *end note*]
+*Ensures:* `lock` is locked by the calling thread.
+*Throws:* Timeout-related exceptions [[thread.req.timing]].
 ``` cpp
 template<class Lock, class Clock, class Duration, class Predicate>
   bool wait_until(Lock& lock, const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
 ```
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
+[*Note 4*: There is no blocking if `pred()` is initially `true`, or if
 the timeout has already expired. — *end note*]
+[*Note 5*: The returned value indicates whether the predicate evaluates
 to `true` regardless of whether the timeout was
 triggered. — *end note*]
 ``` cpp
 template<class Lock, class Rep, class Period, class Predicate>
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
+#### Interruptible waits <a id="thread.condvarany.intwait">[[thread.condvarany.intwait]]</a>
+The following wait functions will be notified when there is a stop
+request on the passed `stop_token`. In that case the functions return
+immediately, returning `false` if the predicate evaluates to `false`.
+``` cpp
+template<class Lock, class Predicate>
+  bool wait(Lock& lock, stop_token stoken, Predicate pred);
+```
+*Effects:* Registers for the duration of this call `*this` to get
+notified on a stop request on `stoken` during this call and then
+equivalent to:
+``` cpp
+while (!stoken.stop_requested()) {
+  if (pred())
+    return true;
+  wait(lock);
+}
+return pred();
+```
+[*Note 1*: The returned value indicates whether the predicate evaluated
+to `true` regardless of whether there was a stop request. — *end note*]
+*Ensures:* `lock` is locked by the calling thread.
+*Remarks:* If the function fails to meet the postcondition, `terminate`
+is called [[except.terminate]].
+[*Note 2*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Throws:* Any exception thrown by `pred`.
+``` cpp
+template<class Lock, class Clock, class Duration, class Predicate>
+  bool wait_until(Lock& lock, stop_token stoken,
+                  const chrono::time_point<Clock, Duration>& abs_time, Predicate pred);
+```
+*Effects:* Registers for the duration of this call `*this` to get
+notified on a stop request on `stoken` during this call and then
+equivalent to:
+``` cpp
+while (!stoken.stop_requested()) {
+  if (pred())
+    return true;
+  if (cv.wait_until(lock, abs_time) == cv_status::timeout)
+    return pred();
+}
+return pred();
+```
+[*Note 3*: There is no blocking if `pred()` is initially `true`,
+`stoken.stop_requested()` was already `true` or the timeout has already
+expired. — *end note*]
+[*Note 4*: The returned value indicates whether the predicate evaluated
+to `true` regardless of whether the timeout was triggered or a stop
+request was made. — *end note*]
+*Ensures:* `lock` is locked by the calling thread.
+*Remarks:* If the function fails to meet the postcondition, `terminate`
+is called [[except.terminate]].
+[*Note 5*: This can happen if the re-locking of the mutex throws an
+exception. — *end note*]
+*Throws:* Timeout-related exceptions [[thread.req.timing]], or any
+exception thrown by `pred`.
+``` cpp
+template<class Lock, class Rep, class Period, class Predicate>
+  bool wait_for(Lock& lock, stop_token stoken,
+                const chrono::duration<Rep, Period>& rel_time, Predicate pred);
+```
+*Effects:* Equivalent to:
+``` cpp
+return wait_until(lock, std::move(stoken), chrono::steady_clock::now() + rel_time,
+                  std::move(pred));
+```

Diff to HTML by rtfpessoa