[thread.mutex] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp0a_rdupc/{from.md → to.md} +17 -27

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

@@ -12,11 +12,11 @@ race-free programs [[intro.multithread]].
 namespace std {
   // [thread.mutex.class], class mutex
   class mutex;
   // [thread.mutex.recursive], class recursive_mutex
   class recursive_mutex;
-  // [thread.timedmutex.class] class timed_mutex
   class timed_mutex;
   // [thread.timedmutex.recursive], class recursive_timed_mutex
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
@@ -61,11 +61,11 @@ namespace std {
 }
 ```
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
-#### In general <a id="thread.mutex.requirements.general">[[thread.mutex.requirements.general]]</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.
@@ -219,13 +219,13 @@ another thread to acquire ownership of that object will fail (for
 released ownership with a call to `unlock()`.
 [*Note 4*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
-`A` appears to have returned from its unlock call. Implementations are
-required to handle such scenarios correctly, as long as thread `A`
-doesn’t access the mutex after the unlock call returns. These cases
 typically occur when a reference-counted object contains a mutex that is
 used to protect the reference count. — *end note*]
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
@@ -281,11 +281,11 @@ ownership for a `recursive_mutex` object, additional calls to
 of type `system_error`. A thread shall call `unlock()` once for each
 level of ownership acquired by calls to `lock()` and `try_lock()`. Only
 when all levels of ownership have been released may ownership be
 acquired by another thread.
-The behavior of a program is undefined if:
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
@@ -392,11 +392,11 @@ a call to `unlock()` or the call to `try_lock_for()` or
 The class `timed_mutex` meets all of the timed mutex requirements
 [[thread.timedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
-The behavior of a program is undefined if:
 - it destroys a `timed_mutex` object owned by any thread,
 - a thread that owns a `timed_mutex` object calls `lock()`,
   `try_lock()`, `try_lock_for()`, or `try_lock_until()` on that object,
   or
@@ -451,11 +451,11 @@ for a `recursive_timed_mutex` object, additional calls to `try_lock()`,
 `unlock()` once for each level of ownership acquired by calls to
 `lock()`, `try_lock()`, `try_lock_for()`, and `try_lock_until()`. Only
 when all levels of ownership have been released may ownership of the
 object be acquired by another thread.
-The behavior of a program is undefined if:
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
@@ -580,11 +580,11 @@ ownership semantics.
 The class `shared_mutex` meets all of the shared mutex requirements
 [[thread.sharedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
-The behavior of a program is undefined if:
 - it destroys a `shared_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
   `shared_mutex`, or
 - a thread terminates while possessing any ownership of a
@@ -706,11 +706,11 @@ shared ownership semantics.
 The class `shared_timed_mutex` meets all of the shared timed mutex
 requirements [[thread.sharedtimedmutex.requirements]]. It is a
 standard-layout class [[class.prop]].
-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
@@ -890,11 +890,11 @@ namespace std {
     unique_lock(const unique_lock&) = delete;
     unique_lock& operator=(const unique_lock&) = delete;
     unique_lock(unique_lock&& u) noexcept;
-    unique_lock& operator=(unique_lock&& u);
     // [thread.lock.unique.locking], locking
     void lock();
     bool try_lock();
@@ -1016,24 +1016,16 @@ unique_lock(unique_lock&& u) noexcept;
 *Ensures:* `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()`.
-*Ensures:* `pm == u_p.pm` and `owns == u_p.owns` (where `u_p` is the
-state of `u` just prior to this construction), `u.pm == 0` and
-`u.owns == false`.
-[*Note 1*: With a recursive mutex it is possible for both `*this` and
-`u` to own the same mutex before the assignment. In this case, `*this`
-will own the mutex after the assignment and `u` will not. — *end note*]
-*Throws:* Nothing.
 ``` cpp
 ~unique_lock();
 ```
@@ -1338,15 +1330,13 @@ state of `sl` just prior to this construction), `sl.pm == nullptr` and
 ``` cpp
 shared_lock& operator=(shared_lock&& sl) noexcept;
 ```
-*Effects:* If `owns` calls `pm->unlock_shared()`.
-*Ensures:* `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`.
 ##### Locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
 ``` cpp
 void lock();
@@ -1571,11 +1561,11 @@ template<class Callable, class... Args>
 *Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
-is an *active* execution. An active execution calls *INVOKE*(
 std::forward\<Callable\>(func),
 std::forward\<Args\>(args)...) [[func.require]]. If such a call to
 `func` throws an exception the execution is *exceptional*, otherwise it
 is *returning*. An exceptional execution propagates the exception to the
 caller of `call_once`. Among all executions of `call_once` for any given

 namespace std {
   // [thread.mutex.class], class mutex
   class mutex;
   // [thread.mutex.recursive], class recursive_mutex
   class recursive_mutex;
+  // [thread.timedmutex.class], class timed_mutex
   class timed_mutex;
   // [thread.timedmutex.recursive], class recursive_timed_mutex
   class recursive_timed_mutex;
   struct defer_lock_t { explicit defer_lock_t() = default; };
 }
 ```
 ### Mutex requirements <a id="thread.mutex.requirements">[[thread.mutex.requirements]]</a>
+#### General <a id="thread.mutex.requirements.general">[[thread.mutex.requirements.general]]</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.
 released ownership with a call to `unlock()`.
 [*Note 4*: After a thread `A` has called `unlock()`, releasing a mutex,
 it is possible for another thread `B` to lock the same mutex, observe
 that it is no longer in use, unlock it, and destroy it, before thread
+`A` appears to have returned from its unlock call. Conforming
+implementations handle such scenarios correctly, as long as thread `A`
+does not access the mutex after the unlock call returns. These cases
 typically occur when a reference-counted object contains a mutex that is
 used to protect the reference count. — *end note*]
 The class `mutex` meets all of the mutex requirements
 [[thread.mutex.requirements]]. It is a standard-layout class
 of type `system_error`. A thread shall call `unlock()` once for each
 level of ownership acquired by calls to `lock()` and `try_lock()`. Only
 when all levels of ownership have been released may ownership be
 acquired by another thread.
+The behavior of a program is undefined if
 - it destroys a `recursive_mutex` object owned by any thread or
 - a thread terminates while owning a `recursive_mutex` object.
 #### Timed mutex types <a id="thread.timedmutex.requirements">[[thread.timedmutex.requirements]]</a>
 The class `timed_mutex` meets all of the timed mutex requirements
 [[thread.timedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
+The behavior of a program is undefined if
 - it destroys a `timed_mutex` object owned by any thread,
 - a thread that owns a `timed_mutex` object calls `lock()`,
   `try_lock()`, `try_lock_for()`, or `try_lock_until()` on that object,
   or
 `unlock()` once for each level of ownership acquired by calls to
 `lock()`, `try_lock()`, `try_lock_for()`, and `try_lock_until()`. Only
 when all levels of ownership have been released may ownership of the
 object be acquired by another thread.
+The behavior of a program is undefined if
 - it destroys a `recursive_timed_mutex` object owned by any thread, or
 - a thread terminates while owning a `recursive_timed_mutex` object.
 #### Shared mutex types <a id="thread.sharedmutex.requirements">[[thread.sharedmutex.requirements]]</a>
 The class `shared_mutex` meets all of the shared mutex requirements
 [[thread.sharedmutex.requirements]]. It is a standard-layout class
 [[class.prop]].
+The behavior of a program is undefined if
 - it destroys a `shared_mutex` object owned by any thread,
 - a thread attempts to recursively gain any ownership of a
   `shared_mutex`, or
 - a thread terminates while possessing any ownership of a
 The class `shared_timed_mutex` meets all of the shared timed mutex
 requirements [[thread.sharedtimedmutex.requirements]]. It is a
 standard-layout class [[class.prop]].
+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
     unique_lock(const unique_lock&) = delete;
     unique_lock& operator=(const unique_lock&) = delete;
     unique_lock(unique_lock&& u) noexcept;
+    unique_lock& operator=(unique_lock&& u) noexcept;
     // [thread.lock.unique.locking], locking
     void lock();
     bool try_lock();
 *Ensures:* `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:* Equivalent to: `unique_lock(std::move(u)).swap(*this)`
+*Returns:* `*this`.
 ``` cpp
 ~unique_lock();
 ```
 ``` cpp
 shared_lock& operator=(shared_lock&& sl) noexcept;
 ```
+*Effects:* Equivalent to: `shared_lock(std::move(sl)).swap(*this)`
+*Returns:* `*this`.
 ##### Locking <a id="thread.lock.shared.locking">[[thread.lock.shared.locking]]</a>
 ``` cpp
 void lock();
 *Mandates:* `is_invocable_v<Callable, Args...>` is `true`.
 *Effects:* An execution of `call_once` that does not call its `func` is
 a *passive* execution. An execution of `call_once` that calls its `func`
+is an *active* execution. An active execution evaluates *INVOKE*(
 std::forward\<Callable\>(func),
 std::forward\<Args\>(args)...) [[func.require]]. If such a call to
 `func` throws an exception the execution is *exceptional*, otherwise it
 is *returning*. An exceptional execution propagates the exception to the
 caller of `call_once`. Among all executions of `call_once` for any given

Diff to HTML by rtfpessoa