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

Files changed (1) hide show

tmp/tmpcfl9g71u/{from.md → to.md} +544 -37

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

@@ -34,11 +34,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>
@@ -47,22 +56,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
@@ -93,12 +100,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.
@@ -121,12 +128,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
@@ -157,12 +164,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>
@@ -263,26 +270,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
@@ -298,17 +304,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
@@ -323,11 +329,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 {
@@ -337,11 +343,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);
@@ -383,11 +389,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);
@@ -427,10 +433,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
@@ -538,11 +738,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();
@@ -682,11 +882,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
@@ -695,10 +895,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()`.
@@ -837,10 +1039,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&...);
 ```
@@ -852,11 +1363,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`.
@@ -931,14 +1442,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;

     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;

Diff to HTML by rtfpessoa