[thread] - C++11 → C++14

Files changed (1) hide show

tmp/tmp0i86jmbz/{from.md → to.md} +723 -217

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

@@ -12,23 +12,23 @@ Table  [[tab:thread.lib.summary]].
 | Subclause            |                     | Header                 |
 | -------------------- | ------------------- | ---------------------- |
 | [[thread.req]]       | Requirements        |                        |
 | [[thread.threads]]   | Threads             | `<thread>`             |
 | [[thread.mutex]]     | Mutual exclusion    | `<mutex>`              |
 | [[thread.condition]] | Condition variables | `<condition_variable>` |
 | [[futures]]          | Futures             | `<future>`             |
 ## Requirements <a id="thread.req">[[thread.req]]</a>
 ### Template parameter names <a id="thread.req.paramname">[[thread.req.paramname]]</a>
 Throughout this Clause, the names of template parameters are used to
-express type requirements.
-If a parameter is `Predicate`, `operator()` applied to the actual
-template argument shall return a value that is convertible to `bool`.
 ### Exceptions <a id="thread.req.exception">[[thread.req.exception]]</a>
 Some functions described in this Clause are specified to throw
 exceptions of type `system_error` ([[syserr.syserr]]). Such exceptions
@@ -117,10 +117,17 @@ operating system and hardware. The finest resolution provided by an
 implementation is called the *native resolution*.
 Implementation-provided clocks that are used for these functions shall
 meet the `TrivialClock` requirements ([[time.clock.req]]).
 ### Requirements for Lockable types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
 #### In general <a id="thread.req.lockable.general">[[thread.req.lockable.general]]</a>
 An *execution agent* is an entity such as a thread that may perform work
@@ -230,11 +237,11 @@ been acquired for the current execution agent.
 In several places in this Clause the operation *DECAY_COPY(x)* is used.
 All such uses mean call the function `decay_copy(x)` and use the result,
 where `decay_copy` is defined as follows:
 ``` cpp
-template <class T> typename decay<T>::type decay_copy(T&& v)
   { return std::forward<T>(v); }
 ```
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
@@ -410,12 +417,12 @@ representations.
 ``` cpp
 template <> struct hash<thread::id>;
 ```
-*Requires:* the template specialization shall meet the requirements of
-class template `hash` ([[unord.hash]]).
 #### `thread` constructors <a id="thread.thread.constr">[[thread.thread.constr]]</a>
 ``` cpp
 thread() noexcept;
@@ -433,10 +440,13 @@ template <class F, class ...Args> explicit thread(F&& f, Args&&... args);
 *Requires:*  `F` and each `Ti` in `Args` shall satisfy the
 `MoveConstructible` requirements. *`INVOKE`*`(`*`DECAY_COPY`*`(`
 `std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)` ([[func.require]])
 shall be a valid expression.
 *Effects:*  Constructs an object of type `thread`. The new thread of
 execution executes
 *`INVOKE`*`(`*`DECAY_COPY`*`(` `std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
 with the calls to *`DECAY_COPY`* being evaluated in the constructing
 thread. Any return value from this invocation is ignored. This implies
@@ -627,15 +637,11 @@ template <class Clock, class Duration>
 *Effects:* Blocks the calling thread for the absolute
 timeout ([[thread.req.timing]]) specified by `abs_time`.
 *Synchronization:* None.
-*Throws:* Nothing if `Clock` satisfies the `TrivialClock`
-requirements ([[time.clock.req]]) and operations of `Duration` do not
-throw exceptions. instantiations of time point types and clocks supplied
-by the implementation as specified in  [[time.clock]] do not throw
-exceptions.
 ``` cpp
 template <class Rep, class Period>
   void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 ```
@@ -643,13 +649,11 @@ template <class Rep, class Period>
 *Effects:* Blocks the calling thread for the relative
 timeout ([[thread.req.timing]]) specified by `rel_time`.
 *Synchronization:* None.
-*Throws:* Nothing if operations of `chrono::duration<Rep, Period>` do
-not throw exceptions. instantiations of duration types supplied by the
-implementation as specified in  [[time.clock]] do not throw exceptions.
 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
 This section provides mechanisms for mutual exclusion: mutexes, locks,
 and call once. These mechanisms ease the production of race-free
@@ -685,11 +689,20 @@ namespace std {
     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);
 }
 ```
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
@@ -698,22 +711,20 @@ namespace std {
 A mutex object facilitates protection against data races and allows safe
 synchronization of data between execution agents (
 [[thread.req.lockable]]). An execution agent *owns* a mutex from the
 time it successfully calls one of the lock functions until it calls
 unlock. Mutexes can be either recursive or non-recursive, and can grant
-simultaneous ownership to one or many execution agents. The mutex types
-supplied by the standard library provide exclusive ownership semantics:
-only one thread may own the mutex at a time. 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`, and
-`std::recursive_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
@@ -744,12 +755,12 @@ 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` or `std::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.
@@ -772,12 +783,12 @@ required ([[thread.req.exception]]).
   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` or `std::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
@@ -808,12 +819,12 @@ The calling thread shall own the mutex.
 *Effects:* Releases the calling thread’s ownership of the mutex.
 *Return type:* `void`
-*Synchronization:* This operation *synchronizes
-with* ([[intro.multithread]]) subsequent lock operations that obtain
 ownership on the same object.
 *Throws:* Nothing.
 ##### Class `mutex` <a id="thread.mutex.class">[[thread.mutex.class]]</a>
@@ -914,26 +925,25 @@ The behavior of a program is undefined if:
 - 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` and `std::recursive_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 the tick `period` of `rel_time` is not exactly convertible to the
-native tick `period`, the `duration` shall be rounded up to the nearest
-native tick `period`. If `m` is of type `std::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
@@ -949,17 +959,17 @@ implementations are expected to make a strong effort to do so.
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
 operations on the same object *synchronize
 with* ([[intro.multithread]]) this operation.
-*Throws:* Nothing.
 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`, 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
@@ -974,11 +984,11 @@ strong effort to do so.
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
 with* ([[intro.multithread]]) this operation.
-*Throws:* Nothing.
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
 namespace std {
@@ -988,11 +998,11 @@ namespace std {
     ~timed_mutex();
     timed_mutex(const timed_mutex&) = delete;
     timed_mutex& operator=(const timed_mutex&) = delete;
-    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);
@@ -1034,11 +1044,11 @@ namespace std {
     ~recursive_timed_mutex();
     recursive_timed_mutex(const recursive_timed_mutex&) = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
-    void lock();
     bool try_lock() noexcept;
     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);
@@ -1078,10 +1088,204 @@ 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.
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
@@ -1189,11 +1393,11 @@ namespace std {
     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) noexcept;
     // [thread.lock.unique.locking], locking:
     void lock();
     bool try_lock();
@@ -1333,11 +1537,11 @@ unique_lock(unique_lock&& u) noexcept;
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
 the state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 ``` cpp
-unique_lock& operator=(unique_lock&& u) noexcept;
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
@@ -1346,10 +1550,12 @@ the state of `u` just prior to this construction), `u.pm == 0` and
 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.
 ``` cpp
 ~unique_lock();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
@@ -1488,10 +1694,319 @@ explicit operator bool() const noexcept;
 mutex_type *mutex() const noexcept;
 ```
 *Returns:* `pm`
 ### Generic locking algorithms <a id="thread.lock.algorithm">[[thread.lock.algorithm]]</a>
 ``` cpp
 template <class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
 ```
@@ -1503,11 +2018,11 @@ 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`.
@@ -1582,14 +2097,10 @@ 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`.
-*Error conditions:*
-- `invalid_argument` — if the `once_flag` object is no longer valid.
 ``` cpp
 // global flag, regular function
 void init();
 std::once_flag flag;
@@ -1636,13 +2147,14 @@ 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 `notify_one`, `notify_all`, and
-each part of the `wait`, `wait_for`, and `wait_until` executions are
-executed in some unspecified total order.
 Condition variable construction and destruction need not be
 synchronized.
 ``` cpp
@@ -1676,14 +2188,13 @@ as if
 ``` cpp
 lk.unlock();
 cond.notify_all();
 ```
-*Synchronization:* The call to `notify_all_at_thread_exit` and the
-completion of the destructors for all the current thread’s variables of
-thread storage duration synchronize with ([[intro.multithread]]) calls
-to functions waiting on `cond`.
 *Note:* 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
@@ -1789,32 +2300,29 @@ void wait(unique_lock<mutex>& lock);
 `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` or `timed_wait`)
-  threads.
 *Effects:*
 - 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()` or
   a call to `notify_all()`, or spuriously.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function scope.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Predicate>
   void wait(unique_lock<mutex>& lock, Predicate pred);
 ```
@@ -1822,29 +2330,29 @@ template <class Predicate>
 *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` or `timed_wait`)
-  threads.
-*Effects:*
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `std::system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Clock, class Duration>
   cv_status wait_until(unique_lock<mutex>& lock,
                        const chrono::time_point<Clock, Duration>& abs_time);
@@ -1866,25 +2374,24 @@ thread, and either
 - 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 scope.
 `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:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Rep, class Period>
   cv_status wait_for(unique_lock<mutex>& lock,
                      const chrono::duration<Rep, Period>& rel_time);
@@ -1896,29 +2403,28 @@ 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.
-*Effects:* as if
 ``` 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`.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Clock, class Duration, class Predicate>
   bool wait_until(unique_lock<mutex>& lock,
                   const chrono::time_point<Clock, Duration>& abs_time,
@@ -1928,36 +2434,34 @@ template <class Clock, class Duration, class Predicate>
 *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` or `timed_wait`)
-  threads.
-*Effects:*
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Returns:* `pred()`
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
 The returned value indicates whether the predicate evaluated to `true`
 regardless of whether the timeout was triggered.
-*Throws:* `std::system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Rep, class Period, class Predicate>
   bool wait_for(unique_lock<mutex>& lock,
                 const chrono::duration<Rep, Period>& rel_time,
@@ -1970,33 +2474,31 @@ 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.
-*Effects:* as if
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
 There is no blocking if `pred()` is initially `true`, even if the
 timeout has already expired.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
-*Returns:* `pred()`
 The returned value indicates whether the predicate evaluates to `true`
 regardless of whether the timeout was triggered.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ### 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]]). All of the standard mutex types meet
@@ -2046,12 +2548,12 @@ condition_variable_any();
 *Throws:* `bad_alloc` or `system_error` when an exception is
 required ([[thread.req.exception]]).
 *Error conditions:*
-- `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.
 ``` cpp
 ~condition_variable_any();
@@ -2096,28 +2598,25 @@ allows to query that, such as the `unique_lock` wrapper.
 - 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.
-- If the function exits via an exception, `lock.lock()` shall be called
-  prior to exiting the function scope.
 `lock` is locked by the calling thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Predicate>
   void wait(Lock& lock, Predicate pred);
 ```
-*Effects:*
 ``` cpp
 while (!pred())
   wait(lock);
 ```
@@ -2135,96 +2634,78 @@ template <class Lock, class Clock, class Duration>
 - 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 scope.
 `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:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` cpp
 template <class Lock, class Rep, class Period>
   cv_status wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time);
 ```
-*Effects:* as if
 ``` 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`.
 `lock` is locked by the calling thread.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ``` 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);
 ```
-*Effects:*
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
-*Returns:* `pred()`
 The returned value indicates whether the predicate evaluates to `true`
 regardless of whether the timeout was triggered.
 ``` cpp
 template <class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```
-*Effects:* as if
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
-There is no blocking if `pred()` is initially `true`, even if the
-timeout has already expired.
-`lock` is locked by the calling thread.
-*Returns:* `pred()`
-The returned value indicates whether the predicate evaluates to `true`
-regardless of whether the timeout was triggered.
-*Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
-*Error conditions:*
-- equivalent error condition from `lock.lock()` or `lock.unlock()`.
 ## Futures <a id="futures">[[futures]]</a>
 ### Overview <a id="futures.overview">[[futures.overview]]</a>
 [[futures]] describes components that a C++program can use to retrieve
@@ -2234,20 +2715,20 @@ restricted to multi-threaded programs but can be useful in
 single-threaded programs as well.
 ``` cpp
 namespace std {
   enum class future_errc {
-    broken_promise,
-    future_already_retrieved,
-    promise_already_satisfied,
-    no_state
   };
   enum class launch : unspecified{} {
     async = unspecified{},
     deferred = unspecified{},
-    implementation-defined{}
   };
   enum class future_status {
     ready,
     timeout,
@@ -2282,33 +2763,34 @@ namespace std {
   template <class> class packaged_task;   // undefined
   template <class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
-  template <class R>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
   template <class R, class Alloc>
     struct uses_allocator<packaged_task<R>, Alloc>;
   template <class F, class... Args>
-    future<typename result_of<F(Args...)>::type>
     async(F&& f, Args&&... args);
   template <class F, class... Args>
-    future<typename result_of<F(Args...)>::type>
     async(launch policy, F&& f, Args&&... args);
 }
 ```
-The `enum` type `launch` is an *implementation-defined* bitmask type (
-[[bitmask.types]]) with `launch::async` and `launch::deferred` denoting
-individual bits. Implementations can provide bitmasks to specify
-restrictions on task interaction by functions launched by `async()`
-applicable to a corresponding subset of available launch policies.
-Implementations can extend the behavior of the first overload of
-`async()` by adding their extensions to the launch policy under the “as
-if” rule.
 ### Error handling <a id="futures.errors">[[futures.errors]]</a>
 ``` cpp
 const error_category& future_category() noexcept;
@@ -2369,11 +2851,11 @@ a (possibly void) value or an exception. Futures, promises, and tasks
 defined in this clause reference such shared state.
 The result can be any kind of object including a function to compute
 that result, as used by `async` when `policy` is `launch::deferred`.
-An *asynchronous return object* is an object that reads results from an
 shared state. A *waiting function* of an asynchronous return object is
 one that potentially blocks to wait for the shared state to be made
 ready. If a waiting function can return before the state is made ready
 because of a timeout ([[thread.req.lockable]]), then it is a *timed
 waiting function*, otherwise it is a *non-timed waiting function*.
@@ -2389,11 +2871,15 @@ When an asynchronous return object or an asynchronous provider is said
 to release its shared state, it means:
 - if the return object or provider holds the last reference to its
   shared state, the shared state is destroyed; and
 - the return object or provider gives up its reference to its shared
-  state.
 When an asynchronous provider is said to make its shared state ready, it
 means:
 - first, the provider marks its shared state as ready; and
@@ -2563,14 +3049,14 @@ that state ready ([[futures.state]]).
 *Throws:*
 - `future_error` if its shared state already has a stored value or
   exception, or
-- for the first version, any exception thrown by the copy constructor of
-  `R`, or
-- for the second version, any exception thrown by the move constructor
-  of `R`.
 *Error conditions:*
 - `promise_already_satisfied` if its shared state already has a stored
   value or exception.
@@ -2602,20 +3088,27 @@ void promise<void>::set_value_at_thread_exit();
 *Effects:* Stores the value `r` in the shared state without making that
 state ready immediately. Schedules that state to be made ready when the
 current thread exits, after all objects of thread storage duration
 associated with the current thread have been destroyed.
-*Throws:* `future_error` if an error condition occurs.
 *Error conditions:*
 - `promise_already_satisfied` if its shared state already has a stored
   value or exception.
 - `no_state` if `*this` has no shared state.
 ``` cpp
-void promise::set_exception_at_thread_exit(exception_ptr p);
 ```
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
 ready when the current thread exits, after all objects of thread storage
@@ -2693,11 +3186,11 @@ out in its description, below.
 ``` cpp
 future() noexcept;
 ```
 *Effects:* constructs an *empty* `future` object that does not refer to
-an shared state.
 `valid() == false`.
 ``` cpp
 future(future&& rhs) noexcept;
@@ -2757,13 +3250,12 @@ member function `get`.
 *Effects:* `wait()`s until the shared state is ready, then retrieves the
 value stored in the shared state.
 *Returns:*
-- `future::get()` returns the value stored in the object’s shared state.
- If the type of the value is `MoveAssignable` the returned value is
-  moved, otherwise it is copied.
 - `future<R&>::get()` returns the reference stored as value in the
   object’s shared state.
 - `future<void>::get()` returns nothing.
 *Throws:* the stored exception, if an exception was stored in the shared
@@ -2800,10 +3292,12 @@ specified by `rel_time` has expired.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   relative timeout ([[thread.req.timing]]) specified by `rel_time` has
   expired.
 ``` cpp
 template <class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
@@ -2819,10 +3313,12 @@ specified by `abs_time` has expired.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   absolute timeout ([[thread.req.timing]]) specified by `abs_time` has
   expired.
 ### Class template `shared_future` <a id="futures.shared_future">[[futures.shared_future]]</a>
 The class template `shared_future` defines a type for asynchronous
 return objects which may share their shared state with other
 asynchronous return objects. A default-constructed `shared_future`
@@ -2879,11 +3375,11 @@ differ only in the return type and return value of the member function
 ``` cpp
 shared_future() noexcept;
 ```
 *Effects:* constructs an *empty* `shared_future` object that does not
-refer to an shared state.
 `valid() == false`.
 ``` cpp
 shared_future(const shared_future& rhs);
@@ -3004,10 +3500,12 @@ specified by `rel_time` has expired.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   relative timeout ([[thread.req.timing]]) specified by `rel_time` has
   expired.
 ``` cpp
 template <class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
@@ -3023,23 +3521,23 @@ specified by `abs_time` has expired.
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   absolute timeout ([[thread.req.timing]]) specified by `abs_time` has
   expired.
 ### Function template `async` <a id="futures.async">[[futures.async]]</a>
 The function template `async` provides a mechanism to launch a function
 potentially in a new thread and provides the result of the function in a
 `future` object with which it shares a shared state.
 ``` cpp
 template <class F, class... Args>
-  future<typename result_of<F(Args...)>::type>
-  async(F&& f, Args&&... args);
 template <class F, class... Args>
-  future<typename result_of<F(Args...)>::type>
-  async(launch policy, F&& f, Args&&... args);
 ```
 *Requires:* `F` and each `Ti` in `Args` shall satisfy the
 `MoveConstructible` requirements.
 *`INVOKE`*`(`*`DECAY_COPY`*`(std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
@@ -3068,28 +3566,37 @@ implementation may choose any of the corresponding policies):
   asynchronous return objects that reference that state.
 - if `policy & launch::deferred` is non-zero — Stores
   *`DECAY_COPY`*`(std::forward<F>(f))` and
   *`DECAY_COPY`*`(std::forward<Args>(args))...` in the shared state.
   These copies of `f` and `args` constitute a *deferred function*.
-  Invocation of the deferred function evaluates *`INVOKE`*`(g, xyz)`
- where `g` is the stored value of *`DECAY_COPY`*`(std::forward<F>(f))`
-  and `xyz` is the stored copy of
-  *`DECAY_COPY`*`(std::forward<Args>(args))...`. The shared state is not
   made ready until the function has completed. The first call to a
   non-timed waiting function ([[futures.state]]) on an asynchronous
   return object referring to this shared state shall invoke the deferred
   function in the thread that called the waiting function. Once
-  evaluation of *`INVOKE`*`(g, xyz)` begins, the function is no longer
-  considered deferred. If this policy is specified together with other
-  policies, such as when using a `policy` value of
   `launch::async | launch::deferred`, implementations should defer
   invocation or the selection of the policy when no more concurrency can
   be effectively exploited.
 *Returns:* An object of type
-`future<typename result_of<F(Args...)>::type>` that refers to the shared
-state created by this call to `async`.
 *Synchronization:* Regardless of the provided `policy` argument,
 - the invocation of `async` synchronizes with ([[intro.multithread]])
   the invocation of `f`. This statement applies even when the
@@ -3100,29 +3607,26 @@ state created by this call to `async`.
 If the implementation chooses the `launch::async` policy,
 - a call to a waiting function on an asynchronous return object that
   shares the shared state created by this `async` call shall block until
-  the associated thread has completed, as if
- joined ([[thread.thread.member]]);
 - the associated thread completion synchronizes
   with ([[intro.multithread]]) the return from the first function that
   successfully detects the ready status of the shared state or with the
   return from the last function that releases the shared state,
   whichever happens first.
-*Throws:* `system_error` if `policy` is `launch::async` and the
 implementation is unable to start a new thread.
 *Error conditions:*
-- `resource_unavailable_try_again` — if `policy` is `launch::async` and
   the system is unable to start a new thread.
-*Remarks:* The first signature shall not participate in overload
-resolution if `decay<F>::type` is `std::launch`.
 ``` cpp
 int work1(int value);
 int work2(int value);
 int work(int value) {
   auto handle = std::async([=]{ return work2(value); });
@@ -3162,12 +3666,12 @@ namespace std {
     template <class F, class Allocator>
       explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
     ~packaged_task();
     // no copy
-    packaged_task(packaged_task&) = delete;
-    packaged_task& operator=(packaged_task&) = delete;
     // move support
     packaged_task(packaged_task&& rhs) noexcept;
     packaged_task& operator=(packaged_task&& rhs) noexcept;
     void swap(packaged_task& other) noexcept;
@@ -3209,10 +3713,14 @@ template <class F, class Allocator>
 *Requires:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `t1, t2, ..., tN`
 are values of the corresponding types in `ArgTypes...`, shall be a valid
 expression. Invoking a copy of `f` shall behave the same as invoking
 `f`.
 *Effects:* constructs a new `packaged_task` object with a shared state
 and initializes the object’s stored task with `std::forward<F>(f)`. The
 constructors that take an `Allocator` argument use it to allocate memory
 needed to store the internal data structures.
@@ -3296,20 +3804,10 @@ or the stored task has already been invoked.
 - `promise_already_satisfied` if the stored task has already been
   invoked.
 - `no_state` if `*this` has no shared state.
-*Synchronization:* a successful call to `operator()` synchronizes
-with ([[intro.multithread]]) a call to any member function of a
-`future` or `shared_future` object that shares the shared state of
-`*this`. The completion of the invocation of the stored task and the
-storage of the result (whether normal or exceptional) into the shared
-state synchronizes with ([[intro.multithread]]) the successful return
-from any member function that detects that the state is set to ready.
-`operator()` synchronizes and serializes with other functions through
-the shared state.
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
 *Effects:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `f` is the stored
@@ -3369,10 +3867,11 @@ template <class R, class Alloc>
 [atomics]: atomics.md#atomics
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
 [class]: class.md#class
 [func.require]: utilities.md#func.require
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future_error]: #futures.future_error
@@ -3397,10 +3896,15 @@ template <class R, class Alloc>
 [thread.decaycopy]: #thread.decaycopy
 [thread.general]: #thread.general
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
 [thread.lock.guard]: #thread.lock.guard
 [thread.lock.unique]: #thread.lock.unique
 [thread.lock.unique.cons]: #thread.lock.unique.cons
 [thread.lock.unique.locking]: #thread.lock.unique.locking
 [thread.lock.unique.mod]: #thread.lock.unique.mod
 [thread.lock.unique.obs]: #thread.lock.unique.obs
@@ -3421,10 +3925,12 @@ template <class R, class Alloc>
 [thread.req.lockable.req]: #thread.req.lockable.req
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.destr]: #thread.thread.destr

 | Subclause            |                     | Header                 |
 | -------------------- | ------------------- | ---------------------- |
 | [[thread.req]]       | Requirements        |                        |
 | [[thread.threads]]   | Threads             | `<thread>`             |
 | [[thread.mutex]]     | Mutual exclusion    | `<mutex>`              |
+|                      |                     | `<shared_mutex>`       |
 | [[thread.condition]] | Condition variables | `<condition_variable>` |
 | [[futures]]          | Futures             | `<future>`             |
 ## Requirements <a id="thread.req">[[thread.req]]</a>
 ### Template parameter names <a id="thread.req.paramname">[[thread.req.paramname]]</a>
 Throughout this Clause, the names of template parameters are used to
+express type requirements. If a template parameter is named `Predicate`,
+`operator()` applied to the template argument shall return a value that
+is convertible to `bool`.
 ### Exceptions <a id="thread.req.exception">[[thread.req.exception]]</a>
 Some functions described in this Clause are specified to throw
 exceptions of type `system_error` ([[syserr.syserr]]). Such exceptions
 implementation is called the *native resolution*.
 Implementation-provided clocks that are used for these functions shall
 meet the `TrivialClock` requirements ([[time.clock.req]]).
+A function that takes an argument which specifies a timeout will throw
+if, during its execution, a clock, time point, or time duration throws
+an exception. Such exceptions are referred to as *timeout-related
+exceptions*. instantiations of clock, time point and duration types
+supplied by the implementation as specified in  [[time.clock]] do not
+throw exceptions.
 ### Requirements for Lockable types <a id="thread.req.lockable">[[thread.req.lockable]]</a>
 #### In general <a id="thread.req.lockable.general">[[thread.req.lockable.general]]</a>
 An *execution agent* is an entity such as a thread that may perform work
 In several places in this Clause the operation *DECAY_COPY(x)* is used.
 All such uses mean call the function `decay_copy(x)` and use the result,
 where `decay_copy` is defined as follows:
 ``` cpp
+template <class T> decay_t<T> decay_copy(T&& v)
   { return std::forward<T>(v); }
 ```
 ## Threads <a id="thread.threads">[[thread.threads]]</a>
 ``` cpp
 template <> struct hash<thread::id>;
 ```
+The template specialization shall meet the requirements of class
+template `hash` ([[unord.hash]]).
 #### `thread` constructors <a id="thread.thread.constr">[[thread.thread.constr]]</a>
 ``` cpp
 thread() noexcept;
 *Requires:*  `F` and each `Ti` in `Args` shall satisfy the
 `MoveConstructible` requirements. *`INVOKE`*`(`*`DECAY_COPY`*`(`
 `std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)` ([[func.require]])
 shall be a valid expression.
+*Remarks:* This constructor shall not participate in overload resolution
+if `decay_t<F>` is the same type as `std::thread`.
 *Effects:*  Constructs an object of type `thread`. The new thread of
 execution executes
 *`INVOKE`*`(`*`DECAY_COPY`*`(` `std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
 with the calls to *`DECAY_COPY`* being evaluated in the constructing
 thread. Any return value from this invocation is ignored. This implies
 *Effects:* Blocks the calling thread for the absolute
 timeout ([[thread.req.timing]]) specified by `abs_time`.
 *Synchronization:* None.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Rep, class Period>
   void sleep_for(const chrono::duration<Rep, Period>& rel_time);
 ```
 *Effects:* Blocks the calling thread for the relative
 timeout ([[thread.req.timing]]) specified by `rel_time`.
 *Synchronization:* None.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ## Mutual exclusion <a id="thread.mutex">[[thread.mutex]]</a>
 This section provides mechanisms for mutual exclusion: mutexes, locks,
 and call once. These mechanisms ease the production of race-free
     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;
 }
 ```
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
 A mutex object facilitates protection against data races and allows safe
 synchronization of data between execution agents (
 [[thread.req.lockable]]). An execution agent *owns* a mutex from the
 time it successfully calls one of the lock functions until it calls
 unlock. Mutexes can be either recursive or non-recursive, and can grant
+simultaneous ownership to one or many execution agents. Both recursive
+and non-recursive mutexes are supplied.
 #### Mutex types <a id="thread.mutex.requirements.mutex">[[thread.mutex.requirements.mutex]]</a>
 The *mutex types* are the standard library types `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
 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.
   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
 *Effects:* Releases the calling thread’s ownership of the mutex.
 *Return type:* `void`
+*Synchronization:* This operation synchronizes
+with ([[intro.multithread]]) subsequent lock operations that obtain
 ownership on the same object.
 *Throws:* Nothing.
 ##### Class `mutex` <a id="thread.mutex.class">[[thread.mutex.class]]</a>
 - 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
 *Synchronization:* If `try_lock_for()` returns `true`, prior `unlock()`
 operations on the same object *synchronize
 with* ([[intro.multithread]]) this operation.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 The expression `m.try_lock_until(abs_time)` shall be well-formed and
 have the following semantics:
+*Requires:* If `m` is of type `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
 *Synchronization:* If `try_lock_until()` returns `true`, prior
 `unlock()` operations on the same object *synchronize
 with* ([[intro.multithread]]) this operation.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
 ##### Class `timed_mutex` <a id="thread.timedmutex.class">[[thread.timedmutex.class]]</a>
 ``` cpp
 namespace std {
     ~timed_mutex();
     timed_mutex(const timed_mutex&) = delete;
     timed_mutex& operator=(const timed_mutex&) = delete;
+    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);
     ~recursive_timed_mutex();
     recursive_timed_mutex(const recursive_timed_mutex&) = delete;
     recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
+    void lock();  // blocking
     bool try_lock() noexcept;
     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);
 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
+no execution agent shall hold a shared lock while another execution
+agent holds an exclusive lock on the same shared mutex type, and
+vice-versa. The maximum number of execution agents which can share a
+shared lock on a single shared mutex type is unspecified, but shall be
+at least 10000. If more than the maximum number of execution agents
+attempt to obtain a shared lock, the excess execution agents shall block
+until the number of shared locks are reduced below the maximum amount by
+other execution agents releasing their shared lock.
+The expression `m.lock_shared()` shall be well-formed and have the
+following semantics:
+*Requires:* The calling thread has no ownership of the mutex.
+*Effects:* Blocks the calling thread until shared ownership of the mutex
+can be obtained for the calling thread. If an exception is thrown then a
+shared lock shall not have been acquired for the current thread.
+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.
+*Effects:* Releases a shared lock on the mutex held by the calling
+thread.
+*Return type:* `void`.
+*Synchronization:* This operation synchronizes
+with ([[intro.multithread]]) subsequent `lock()` operations that obtain
+ownership on the same object.
+*Throws:* Nothing.
+The expression `m.try_lock_shared()` shall be well-formed and have the
+following semantics:
+*Requires:* The calling thread has no ownership of the mutex.
+*Effects:* Attempts to obtain shared ownership of the mutex for the
+calling thread without blocking. If shared ownership is not obtained,
+there is no effect and `try_lock_shared()` immediately returns. An
+implementation may fail to obtain the lock even if it is not held by any
+other thread.
+*Return type:* `bool`.
+*Returns:* `true` if the shared ownership lock was acquired, `false`
+otherwise.
+*Synchronization:* If `try_lock_shared()` returns `true`, prior
+`unlock()` operations on the same object synchronize with
+ ([[intro.multithread]]) this operation.
+*Throws:* Nothing.
+The expression `m.try_lock_shared_for(rel_time)` shall be well-formed
+and have the following semantics:
+*Requires:* The calling thread has no ownership of the mutex.
+*Effects:* Attempts to obtain shared lock ownership for the calling
+thread within the relative timeout ([[thread.req.timing]]) specified by
+`rel_time`. If the time specified by `rel_time` is less than or equal to
+`rel_time.zero()`, the function attempts to obtain ownership without
+blocking (as if by calling `try_lock_shared()`). The function shall
+return within the timeout specified by `rel_time` only if it has
+obtained shared ownership of the mutex object. 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.
+*Synchronization:* If `try_lock_shared_for()` returns `true`, prior
+`unlock()` operations on the same object synchronize
+with ([[intro.multithread]]) this operation.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
+The expression `m.try_lock_shared_until(abs_time)` shall be well-formed
+and have the following semantics:
+*Requires:* The calling thread has no ownership of the mutex.
+*Effects:* The function attempts to obtain shared ownership of the
+mutex. If `abs_time` has already passed, the function attempts to obtain
+shared ownership without blocking (as if by calling
+`try_lock_shared()`). The function shall return before the absolute
+timeout ([[thread.req.timing]]) specified by `abs_time` only if it has
+obtained shared ownership of the mutex object. 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.
+*Synchronization:* If `try_lock_shared_until()` returns `true`, prior
+`unlock()` operations on the same object synchronize
+with ([[intro.multithread]]) this operation.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]).
+##### Class `shared_timed_mutex` <a id="thread.sharedtimedmutex.class">[[thread.sharedtimedmutex.class]]</a>
+``` cpp
+namespace std {
+  class shared_timed_mutex {
+  public:
+    shared_timed_mutex();
+    ~shared_timed_mutex();
+    shared_timed_mutex(const shared_timed_mutex&) = delete;
+    shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;
+    // Exclusive ownership
+    void lock();  // blocking
+    bool try_lock();
+    template <class Rep, class Period>
+      bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
+    template <class Clock, class Duration>
+      bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
+    void unlock();
+    // Shared ownership
+    void lock_shared();  // blocking
+    bool try_lock_shared();
+    template <class Rep, class Period>
+      bool
+      try_lock_shared_for(const chrono::duration<Rep, Period>& rel_time);
+    template <class Clock, class Duration>
+      bool
+      try_lock_shared_until(const chrono::time_point<Clock, Duration>& abs_time);
+    void unlock_shared();
+  };
+}
+```
+The class `shared_timed_mutex` provides a non-recursive mutex with
+shared ownership semantics.
+The class `shared_timed_mutex` shall satisfy all of the
+`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
+  `shared_timed_mutex`, or
+- a thread terminates while possessing any ownership of a
+  `shared_timed_mutex`.
 ### Locks <a id="thread.lock">[[thread.lock]]</a>
 A *lock* is an object that holds a reference to a lockable object and
 may unlock the lockable object during the lock’s destruction (such as
 when leaving block scope). An execution agent may use a lock to aid in
     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();
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
 the state of `u` just prior to this construction), `u.pm == 0` and
 `u.owns == false`.
 ``` cpp
+unique_lock& operator=(unique_lock&& u);
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
 *Postconditions:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is
 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();
 ```
 *Effects:* If `owns` calls `pm->unlock()`.
 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);
+  template <class Clock, class Duration>
+    shared_lock(mutex_type& m,
+                const chrono::time_point<Clock, Duration>& abs_time);
+  template <class Rep, class Period>
+    shared_lock(mutex_type& m,
+                const chrono::duration<Rep, Period>& rel_time);
+  ~shared_lock();
+  shared_lock(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
+transferred, after acquisition, to another `shared_lock` object. Objects
+of type `shared_lock` are not copyable but are movable. The behavior of
+a program is undefined if the contained pointer `pm` is not null and the
+lockable object pointed to by `pm` does not exist for the entire
+remaining lifetime ([[basic.life]]) of the `shared_lock` object. The
+supplied `Mutex` type shall meet the shared mutex requirements (
+[[thread.sharedtimedmutex.requirements]]).
+`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;
+```
+*Effects:* Constructs an object of type `shared_lock`.
+*Postconditions:* `pm == nullptr` and `owns == false`.
+``` cpp
+explicit shared_lock(mutex_type& m);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.lock_shared()`.
+*Postconditions:* `pm == &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);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.try_lock_shared()`.
+*Postconditions:* `pm == &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);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.try_lock_shared_until(abs_time)`.
+*Postconditions:* `pm == &m` and `owns == res` where `res` is the value
+returned by the call to `m.try_lock_shared_until(abs_time)`.
+``` cpp
+template <class Rep, class Period>
+  shared_lock(mutex_type& m,
+              const chrono::duration<Rep, Period>& rel_time);
+```
+*Requires:* The calling thread does not own the mutex for any ownership
+mode.
+*Effects:* Constructs an object of type `shared_lock` and calls
+`m.try_lock_shared_for(rel_time)`.
+*Postconditions:* `pm == &m` and `owns == res` where `res` is the value
+returned by the call to `m.try_lock_shared_for(rel_time)`.
+``` cpp
+~shared_lock();
+```
+*Effects:* If `owns` calls `pm->unlock_shared()`.
+``` 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`.
+##### `shared_lock` modifiers <a id="thread.lock.shared.mod">[[thread.lock.shared.mod]]</a>
+``` cpp
+void swap(shared_lock& sl) noexcept;
+```
+*Effects:* Swaps the data members of `*this` and `sl`.
+``` cpp
+mutex_type* release() noexcept;
+```
+*Returns:* The previous value of `pm`.
+*Postconditions:* `pm == nullptr` and `owns == false`.
+``` cpp
+template <class Mutex>
+  void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
+```
+*Effects:* `x.swap(y)`.
+##### `shared_lock` observers <a id="thread.lock.shared.obs">[[thread.lock.shared.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`.
 ### Generic locking algorithms <a id="thread.lock.algorithm">[[thread.lock.algorithm]]</a>
 ``` cpp
 template <class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
 ```
 *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`.
 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;
 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.
 ``` cpp
 ``` 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:* 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
 `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.
 *Effects:*
 - 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()` or
   a call to `notify_all()`, or spuriously.
+*Remarks:* If the function fails to meet the postcondition,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `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.
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   wait(lock);
 ```
+*Remarks:* If the function fails to meet the postcondition,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
+*Throws:* Timeout-related exceptions ([[thread.req.timing]]) or 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);
 - 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,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `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);
 - 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.
+*Effects:* Equivalent to:
 ``` 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,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `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,
 *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.
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
+*Remarks:* If the function fails to meet the postcondition,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
 The returned value indicates whether the predicate evaluated to `true`
 regardless of whether the timeout was triggered.
+*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,
 - 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.
+*Effects:* Equivalent to:
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
 There is no blocking if `pred()` is initially `true`, even if the
 timeout has already expired.
+*Remarks:* If the function fails to meet the postcondition,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `lock.owns_lock()` is `true` and `lock.mutex()` is locked by the calling
 thread.
 The returned value indicates whether the predicate evaluates to `true`
 regardless of whether the timeout was triggered.
+*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]]). All of the standard mutex types meet
 *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.
 - `operation_not_permitted` — if the thread does not have the privilege
   to perform the operation.
 ``` cpp
 ~condition_variable_any();
 - 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,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `lock` is locked by the calling thread.
+*Throws:* Nothing.
 ``` cpp
 template <class Lock, class Predicate>
   void wait(Lock& lock, Predicate pred);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   wait(lock);
 ```
 - 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,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `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);
 ```
+*Effects:* Equivalent to:
 ``` 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,
+`std::terminate()` shall be called ([[except.terminate]]). This can
+happen if the re-locking of the mutex throws an exception.
 `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);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 while (!pred())
   if (wait_until(lock, abs_time) == cv_status::timeout)
     return pred();
 return true;
 ```
+There is no blocking if `pred()` is initially `true`, or if the timeout
+has already expired.
 The returned value indicates whether the predicate evaluates to `true`
 regardless of whether the timeout was triggered.
 ``` cpp
 template <class Lock, class Rep, class Period, class Predicate>
   bool wait_for(Lock& lock, const chrono::duration<Rep, Period>& rel_time, Predicate pred);
 ```
+*Effects:* Equivalent to:
 ``` cpp
 return wait_until(lock, chrono::steady_clock::now() + rel_time, std::move(pred));
 ```
 ## Futures <a id="futures">[[futures]]</a>
 ### Overview <a id="futures.overview">[[futures.overview]]</a>
 [[futures]] describes components that a C++program can use to retrieve
 single-threaded programs as well.
 ``` cpp
 namespace std {
   enum class future_errc {
+    broken_promise = implementation-defined,
+    future_already_retrieved = implementation-defined,
+    promise_already_satisfied = implementation-defined,
+    no_state = implementation-defined
   };
   enum class launch : unspecified{} {
     async = unspecified{},
     deferred = unspecified{},
+    implementation-defined
   };
   enum class future_status {
     ready,
     timeout,
   template <class> class packaged_task;   // undefined
   template <class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
+  template <class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
   template <class R, class Alloc>
     struct uses_allocator<packaged_task<R>, Alloc>;
   template <class F, class... Args>
+    future<result_of_t<decay_t<F>(decay_t<Args>...)>>
     async(F&& f, Args&&... args);
   template <class F, class... Args>
+    future<result_of_t<decay_t<F>(decay_t<Args>...)>>
     async(launch policy, F&& f, Args&&... args);
 }
 ```
+The `enum` type `launch` is a bitmask type ([[bitmask.types]]) with
+`launch::async` and `launch::deferred` denoting individual bits.
+Implementations can provide bitmasks to specify restrictions on task
+interaction by functions launched by `async()` applicable to a
+corresponding subset of available launch policies. Implementations can
+extend the behavior of the first overload of `async()` by adding their
+extensions to the launch policy under the “as if” rule.
+The enum values of `future_errc` are distinct and not zero.
 ### Error handling <a id="futures.errors">[[futures.errors]]</a>
 ``` cpp
 const error_category& future_category() noexcept;
 defined in this clause reference such shared state.
 The result can be any kind of object including a function to compute
 that result, as used by `async` when `policy` is `launch::deferred`.
+An *asynchronous return object* is an object that reads results from a
 shared state. A *waiting function* of an asynchronous return object is
 one that potentially blocks to wait for the shared state to be made
 ready. If a waiting function can return before the state is made ready
 because of a timeout ([[thread.req.lockable]]), then it is a *timed
 waiting function*, otherwise it is a *non-timed waiting function*.
 to release its shared state, it means:
 - if the return object or provider holds the last reference to its
   shared state, the shared state is destroyed; and
 - the return object or provider gives up its reference to its shared
+  state; and
+- these actions will not block for the shared state to become ready,
+  except that it may block if all of the following are true: the shared
+  state was created by a call to `std::async`, the shared state is not
+  yet ready, and this was the last reference to the shared state.
 When an asynchronous provider is said to make its shared state ready, it
 means:
 - first, the provider marks its shared state as ready; and
 *Throws:*
 - `future_error` if its shared state already has a stored value or
   exception, or
+- for the first version, any exception thrown by the constructor
+ selected to copy an object of `R`, or
+- for the second version, any exception thrown by the constructor
+ selected to move an object of `R`.
 *Error conditions:*
 - `promise_already_satisfied` if its shared state already has a stored
   value or exception.
 *Effects:* Stores the value `r` in the shared state without making that
 state ready immediately. Schedules that state to be made ready when the
 current thread exits, after all objects of thread storage duration
 associated with the current thread have been destroyed.
+*Throws:*
+- `future_error` if its shared state already has a stored value or
+  exception, or
+- for the first version, any exception thrown by the constructor
+  selected to copy an object of `R`, or
+- for the second version, any exception thrown by the constructor
+  selected to move an object of `R`.
 *Error conditions:*
 - `promise_already_satisfied` if its shared state already has a stored
   value or exception.
 - `no_state` if `*this` has no shared state.
 ``` cpp
+void set_exception_at_thread_exit(exception_ptr p);
 ```
 *Effects:* Stores the exception pointer `p` in the shared state without
 making that state ready immediately. Schedules that state to be made
 ready when the current thread exits, after all objects of thread storage
 ``` cpp
 future() noexcept;
 ```
 *Effects:* constructs an *empty* `future` object that does not refer to
+a shared state.
 `valid() == false`.
 ``` cpp
 future(future&& rhs) noexcept;
 *Effects:* `wait()`s until the shared state is ready, then retrieves the
 value stored in the shared state.
 *Returns:*
+- `future::get()` returns the value `v` stored in the object’s shared
+ state as `std::move(v)`.
 - `future<R&>::get()` returns the reference stored as value in the
   object’s shared state.
 - `future<void>::get()` returns nothing.
 *Throws:* the stored exception, if an exception was stored in the shared
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   relative timeout ([[thread.req.timing]]) specified by `rel_time` has
   expired.
+*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   absolute timeout ([[thread.req.timing]]) specified by `abs_time` has
   expired.
+*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ### Class template `shared_future` <a id="futures.shared_future">[[futures.shared_future]]</a>
 The class template `shared_future` defines a type for asynchronous
 return objects which may share their shared state with other
 asynchronous return objects. A default-constructed `shared_future`
 ``` cpp
 shared_future() noexcept;
 ```
 *Effects:* constructs an *empty* `shared_future` object that does not
+refer to a shared state.
 `valid() == false`.
 ``` cpp
 shared_future(const shared_future& rhs);
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   relative timeout ([[thread.req.timing]]) specified by `rel_time` has
   expired.
+*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ``` cpp
 template <class Clock, class Duration>
   future_status wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 ```
 - `future_status::ready` if the shared state is ready.
 - `future_status::timeout` if the function is returning because the
   absolute timeout ([[thread.req.timing]]) specified by `abs_time` has
   expired.
+*Throws:* timeout-related exceptions ([[thread.req.timing]]).
 ### Function template `async` <a id="futures.async">[[futures.async]]</a>
 The function template `async` provides a mechanism to launch a function
 potentially in a new thread and provides the result of the function in a
 `future` object with which it shares a shared state.
 ``` cpp
 template <class F, class... Args>
+  future<result_of_t<decay_t<F>(decay_t<Args>...)>> async(F&& f, Args&&... args);
 template <class F, class... Args>
+  future<result_of_t<decay_t<F>(decay_t<Args>...)>> async(launch policy, F&& f, Args&&... args);
 ```
 *Requires:* `F` and each `Ti` in `Args` shall satisfy the
 `MoveConstructible` requirements.
 *`INVOKE`*`(`*`DECAY_COPY`*`(std::forward<F>(f)), `*`DECAY_COPY`*`(std::forward<Args>(args))...)`
   asynchronous return objects that reference that state.
 - if `policy & launch::deferred` is non-zero — Stores
   *`DECAY_COPY`*`(std::forward<F>(f))` and
   *`DECAY_COPY`*`(std::forward<Args>(args))...` in the shared state.
   These copies of `f` and `args` constitute a *deferred function*.
+  Invocation of the deferred function evaluates
+  *`INVOKE`*`(std::move(g), std::move(xyz))` where `g` is the stored
+ value of *`DECAY_COPY`*`(std::forward<F>(f))` and `xyz` is the stored
+ copy of *`DECAY_COPY`*`(std::forward<Args>(args))...`. Any return
+  value is stored as the result in the shared state. Any exception
+  propagated from the execution of the deferred function is stored as
+  the exceptional result in the shared state. The shared state is not
   made ready until the function has completed. The first call to a
   non-timed waiting function ([[futures.state]]) on an asynchronous
   return object referring to this shared state shall invoke the deferred
   function in the thread that called the waiting function. Once
+  evaluation of *`INVOKE`*`(std::move(g), std::move(xyz))` begins, the
+ function is no longer considered deferred. If this policy is specified
+ together with other policies, such as when using a `policy` value of
   `launch::async | launch::deferred`, implementations should defer
   invocation or the selection of the policy when no more concurrency can
   be effectively exploited.
+- If no value is set in the launch policy, or a value is set that is
+  neither specified in this International Standard or by the
+  implementation, the behaviour is undefined.
 *Returns:* An object of type
+`future<result_of_t<decay_t<F>(decay_t<Args>...)>``>` that refers to the
+shared state created by this call to `async`. If a future obtained from
+std::async is moved outside the local scope, other code that uses the
+future must be aware that the future’s destructor may block for the
+shared state to become ready.
 *Synchronization:* Regardless of the provided `policy` argument,
 - the invocation of `async` synchronizes with ([[intro.multithread]])
   the invocation of `f`. This statement applies even when the
 If the implementation chooses the `launch::async` policy,
 - a call to a waiting function on an asynchronous return object that
   shares the shared state created by this `async` call shall block until
+  the associated thread has completed, as if joined, or else time
+ out ([[thread.thread.member]]);
 - the associated thread completion synchronizes
   with ([[intro.multithread]]) the return from the first function that
   successfully detects the ready status of the shared state or with the
   return from the last function that releases the shared state,
   whichever happens first.
+*Throws:* `system_error` if `policy == launch::async` and the
 implementation is unable to start a new thread.
 *Error conditions:*
+- `resource_unavailable_try_again` — if `policy == launch::async` and
   the system is unable to start a new thread.
 ``` cpp
 int work1(int value);
 int work2(int value);
 int work(int value) {
   auto handle = std::async([=]{ return work2(value); });
     template <class F, class Allocator>
       explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f);
     ~packaged_task();
     // no copy
+    packaged_task(const packaged_task&) = delete;
+    packaged_task& operator=(const packaged_task&) = delete;
     // move support
     packaged_task(packaged_task&& rhs) noexcept;
     packaged_task& operator=(packaged_task&& rhs) noexcept;
     void swap(packaged_task& other) noexcept;
 *Requires:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `t1, t2, ..., tN`
 are values of the corresponding types in `ArgTypes...`, shall be a valid
 expression. Invoking a copy of `f` shall behave the same as invoking
 `f`.
+*Remarks:* These constructors shall not participate in overload
+resolution if `decay_t<F>` is the same type as
+`std::packaged_task<R(ArgTypes...)>`.
 *Effects:* constructs a new `packaged_task` object with a shared state
 and initializes the object’s stored task with `std::forward<F>(f)`. The
 constructors that take an `Allocator` argument use it to allocate memory
 needed to store the internal data structures.
 - `promise_already_satisfied` if the stored task has already been
   invoked.
 - `no_state` if `*this` has no shared state.
 ``` cpp
 void make_ready_at_thread_exit(ArgTypes... args);
 ```
 *Effects:* *`INVOKE`*`(f, t1, t2, ..., tN, R)`, where `f` is the stored
 [atomics]: atomics.md#atomics
 [basic.life]: basic.md#basic.life
 [basic.stc.thread]: basic.md#basic.stc.thread
 [bitmask.types]: library.md#bitmask.types
 [class]: class.md#class
+[except.terminate]: except.md#except.terminate
 [func.require]: utilities.md#func.require
 [futures]: #futures
 [futures.async]: #futures.async
 [futures.errors]: #futures.errors
 [futures.future_error]: #futures.future_error
 [thread.decaycopy]: #thread.decaycopy
 [thread.general]: #thread.general
 [thread.lock]: #thread.lock
 [thread.lock.algorithm]: #thread.lock.algorithm
 [thread.lock.guard]: #thread.lock.guard
+[thread.lock.shared]: #thread.lock.shared
+[thread.lock.shared.cons]: #thread.lock.shared.cons
+[thread.lock.shared.locking]: #thread.lock.shared.locking
+[thread.lock.shared.mod]: #thread.lock.shared.mod
+[thread.lock.shared.obs]: #thread.lock.shared.obs
 [thread.lock.unique]: #thread.lock.unique
 [thread.lock.unique.cons]: #thread.lock.unique.cons
 [thread.lock.unique.locking]: #thread.lock.unique.locking
 [thread.lock.unique.mod]: #thread.lock.unique.mod
 [thread.lock.unique.obs]: #thread.lock.unique.obs
 [thread.req.lockable.req]: #thread.req.lockable.req
 [thread.req.lockable.timed]: #thread.req.lockable.timed
 [thread.req.native]: #thread.req.native
 [thread.req.paramname]: #thread.req.paramname
 [thread.req.timing]: #thread.req.timing
+[thread.sharedtimedmutex.class]: #thread.sharedtimedmutex.class
+[thread.sharedtimedmutex.requirements]: #thread.sharedtimedmutex.requirements
 [thread.thread.algorithm]: #thread.thread.algorithm
 [thread.thread.assign]: #thread.thread.assign
 [thread.thread.class]: #thread.thread.class
 [thread.thread.constr]: #thread.thread.constr
 [thread.thread.destr]: #thread.thread.destr

Diff to HTML by rtfpessoa