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

Files changed (1) hide show

tmp/tmprny_zjuw/{from.md → to.md} +339 -102

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

@@ -7,15 +7,21 @@ manage threads.
 system threads. — *end note*]
 ### Header `<thread>` synopsis <a id="thread.syn">[[thread.syn]]</a>
 ``` cpp
 namespace std {
   class thread;
   void swap(thread& x, thread& y) noexcept;
   namespace this_thread {
     thread::id get_id() noexcept;
     void yield() noexcept;
     template<class Clock, class Duration>
@@ -45,33 +51,33 @@ successful call to `detach` or `join`. — *end note*]
 ``` cpp
 namespace std {
   class thread {
   public:
-    // types:
     class id;
-    using native_handle_type = implementation-defined; // See~[thread.req.native]
-    // construct/copy/destroy:
     thread() noexcept;
     template<class F, class... Args> explicit thread(F&& f, Args&&... args);
     ~thread();
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
-    // members:
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
-    native_handle_type native_handle(); // See~[thread.req.native]
-    // static members:
-    static unsigned hardware_concurrency() noexcept;
   };
 }
 ```
 #### Class `thread::id` <a id="thread.thread.id">[[thread.thread.id]]</a>
@@ -82,150 +88,129 @@ namespace std {
   public:
     id() noexcept;
   };
   bool operator==(thread::id x, thread::id y) noexcept;
- bool operator!=(thread::id x, thread::id y) noexcept;
-  bool operator<(thread::id x, thread::id y) noexcept;
-  bool operator<=(thread::id x, thread::id y) noexcept;
-  bool operator>(thread::id x, thread::id y) noexcept;
-  bool operator>=(thread::id x, thread::id y) noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
-  // Hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
 An object of type `thread::id` provides a unique identifier for each
 thread of execution and a single distinct value for all `thread` objects
-that do not represent a thread of execution ([[thread.thread.class]]).
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
-`thread::id` shall be a trivially copyable class (Clause  [[class]]).
-The library may reuse the value of a `thread::id` of a terminated thread
-that can no longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
 as keys in associative containers. — *end note*]
 ``` cpp
 id() noexcept;
 ```
-*Effects:* Constructs an object of type `id`.
-*Postconditions:* The constructed object does not represent a thread of
 execution.
 ``` cpp
 bool operator==(thread::id x, thread::id y) noexcept;
 ```
 *Returns:* `true` only if `x` and `y` represent the same thread of
 execution or neither `x` nor `y` represents a thread of execution.
 ``` cpp
-bool operator!=(thread::id x, thread::id y) noexcept;
 ```
-*Returns:* `!(x == y)`
-``` cpp
-bool operator<(thread::id x, thread::id y) noexcept;
-```
-*Returns:* A value such that `operator<` is a total ordering as
-described in  [[alg.sorting]].
-``` cpp
-bool operator<=(thread::id x, thread::id y) noexcept;
-```
-*Returns:* `!(y < x)`.
-``` cpp
-bool operator>(thread::id x, thread::id y) noexcept;
-```
-*Returns:* `y < x`.
-``` cpp
-bool operator>=(thread::id x, thread::id y) noexcept;
-```
-*Returns:* `!(x < y)`.
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
 *Effects:* Inserts an unspecified text representation of `id` into
 `out`. For two objects of type `thread::id` `x` and `y`, if `x == y` the
-`thread::id` objects shall have the same text representation and if
-`x != y` the `thread::id` objects shall have distinct text
-representations.
 *Returns:* `out`.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
-The specialization is enabled ([[unord.hash]]).
-#### `thread` constructors <a id="thread.thread.constr">[[thread.thread.constr]]</a>
 ``` cpp
 thread() noexcept;
 ```
-*Effects:* Constructs a `thread` object that does not represent a thread
-of execution.
-*Postconditions:* `get_id() == id()`.
 ``` cpp
 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.
-*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.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
-If the invocation of
-` `*`INVOKE`*`( `*`DECAY_COPY`*`( std::forward<F>(f)), `*`DECAY_COPY`*`( std::forward<Args>(args))...)`
-terminates with an uncaught exception, `terminate` shall be called.
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
-*Postconditions:* `get_id() != id()`. `*this` represents the newly
-started thread.
 *Throws:* `system_error` if unable to start the new thread.
 *Error conditions:*
@@ -235,45 +220,43 @@ started thread.
 ``` cpp
 thread(thread&& x) noexcept;
 ```
-*Effects:* Constructs an object of type `thread` from `x`, and sets `x`
-to a default constructed state.
-*Postconditions:* `x.get_id() == id()` and `get_id()` returns the value
-of `x.get_id()` prior to the start of construction.
-#### `thread` destructor <a id="thread.thread.destr">[[thread.thread.destr]]</a>
 ``` cpp
 ~thread();
 ```
-If `joinable()`, calls `terminate()`. Otherwise, has no effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
 in its destructor could result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
 exception is thrown. Thus the programmer must ensure that the destructor
 is never executed while the thread is still joinable. — *end note*]
-#### `thread` assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
 *Effects:* If `joinable()`, calls `terminate()`. Otherwise, assigns the
 state of `x` to `*this` and sets `x` to a default constructed state.
-*Postconditions:* `x.get_id() == id()` and `get_id()` returns the value
-of `x.get_id()` prior to the assignment.
 *Returns:* `*this`.
-#### `thread` members <a id="thread.thread.member">[[thread.thread.member]]</a>
 ``` cpp
 void swap(thread& x) noexcept;
 ```
@@ -287,24 +270,23 @@ bool joinable() const noexcept;
 ``` cpp
 void join();
 ```
-*Effects:*  Blocks until the thread represented by `*this` has
-completed.
 *Synchronization:* The completion of the thread represented by `*this`
-synchronizes with ([[intro.multithread]]) the corresponding successful
 `join()` return.
 [*Note 1*: Operations on `*this` are not synchronized. — *end note*]
-*Postconditions:* The thread represented by `*this` has completed.
 `get_id() == id()`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `resource_deadlock_would_occur` — if deadlock is detected or
   `get_id() == this_thread::get_id()`.
@@ -317,16 +299,16 @@ void detach();
 *Effects:* The thread represented by `*this` continues execution without
 the calling thread blocking. When `detach()` returns, `*this` no longer
 represents the possibly continuing thread of execution. When the thread
 previously represented by `*this` ends execution, the implementation
-shall release any owned resources.
-*Postconditions:* `get_id() == id()`.
 *Throws:* `system_error` when an exception is
-required ([[thread.req.exception]]).
 *Error conditions:*
 - `no_such_process` — if the thread is not valid.
 - `invalid_argument` — if the thread is not joinable.
@@ -337,32 +319,288 @@ id get_id() const noexcept;
 *Returns:* A default constructed `id` object if `*this` does not
 represent a thread, otherwise `this_thread::get_id()` for the thread of
 execution represented by `*this`.
-#### `thread` static members <a id="thread.thread.static">[[thread.thread.static]]</a>
 ``` cpp
 unsigned hardware_concurrency() noexcept;
 ```
 *Returns:* The number of hardware thread contexts.
 [*Note 1*: This value should only be considered to be a
 hint. — *end note*]
-If this value is not computable or well defined an implementation should
-return 0.
-#### `thread` specialized algorithms <a id="thread.thread.algorithm">[[thread.thread.algorithm]]</a>
 ``` cpp
 void swap(thread& x, thread& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
 ### Namespace `this_thread` <a id="thread.thread.this">[[thread.thread.this]]</a>
 ``` cpp
 namespace std::this_thread {
   thread::id get_id() noexcept;
@@ -378,14 +616,13 @@ namespace std::this_thread {
 ``` cpp
 thread::id this_thread::get_id() noexcept;
 ```
 *Returns:* An object of type `thread::id` that uniquely identifies the
-current thread of execution. No other thread of execution shall have
-this id and this thread of execution shall always have this id. The
-object returned shall not compare equal to a default constructed
-`thread::id`.
 ``` cpp
 void this_thread::yield() noexcept;
 ```
@@ -397,23 +634,23 @@ void this_thread::yield() noexcept;
 template<class Clock, class Duration>
   void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *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]]).

 system threads. — *end note*]
 ### Header `<thread>` synopsis <a id="thread.syn">[[thread.syn]]</a>
 ``` cpp
+#include <compare>              // see [compare.syn]
+#include <initializer_list>     // see [initializer.list.syn]
 namespace std {
   class thread;
   void swap(thread& x, thread& y) noexcept;
+  // [thread.jthread.class] class jthread
+  class jthread;
   namespace this_thread {
     thread::id get_id() noexcept;
     void yield() noexcept;
     template<class Clock, class Duration>
 ``` cpp
 namespace std {
   class thread {
   public:
+    // types
     class id;
+    using native_handle_type = implementation-defined; // see~[thread.req.native]
+    // construct/copy/destroy
     thread() noexcept;
     template<class F, class... Args> explicit thread(F&& f, Args&&... args);
     ~thread();
     thread(const thread&) = delete;
     thread(thread&&) noexcept;
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
+    // members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
     void detach();
     id get_id() const noexcept;
+    native_handle_type native_handle(); // see~[thread.req.native]
+    // static members
+    static unsigned int hardware_concurrency() noexcept;
   };
 }
 ```
 #### Class `thread::id` <a id="thread.thread.id">[[thread.thread.id]]</a>
   public:
     id() noexcept;
   };
   bool operator==(thread::id x, thread::id y) noexcept;
+ strong_ordering operator<=>(thread::id x, thread::id y) noexcept;
   template<class charT, class traits>
     basic_ostream<charT, traits>&
       operator<<(basic_ostream<charT, traits>& out, thread::id id);
+  // hash support
   template<class T> struct hash;
   template<> struct hash<thread::id>;
 }
 ```
 An object of type `thread::id` provides a unique identifier for each
 thread of execution and a single distinct value for all `thread` objects
+that do not represent a thread of execution [[thread.thread.class]].
 Each thread of execution has an associated `thread::id` object that is
 not equal to the `thread::id` object of any other thread of execution
 and that is not equal to the `thread::id` object of any `thread` object
 that does not represent threads of execution.
+`thread::id` is a trivially copyable class [[class.prop]]. The library
+may reuse the value of a `thread::id` of a terminated thread that can no
+longer be joined.
 [*Note 1*: Relational operators allow `thread::id` objects to be used
 as keys in associative containers. — *end note*]
 ``` cpp
 id() noexcept;
 ```
+*Ensures:* The constructed object does not represent a thread of
 execution.
 ``` cpp
 bool operator==(thread::id x, thread::id y) noexcept;
 ```
 *Returns:* `true` only if `x` and `y` represent the same thread of
 execution or neither `x` nor `y` represents a thread of execution.
 ``` cpp
+strong_ordering operator<=>(thread::id x, thread::id y) noexcept;
 ```
+Let P(`x`, `y`) be an unspecified total ordering over `thread::id` as
+described in [[alg.sorting]].
+*Returns:* `strong_ordering::less` if P(`x`, `y`) is `true`. Otherwise,
+`strong_ordering::greater` if P(`y`, `x`) is `true`. Otherwise,
+`strong_ordering::equal`.
 ``` cpp
 template<class charT, class traits>
   basic_ostream<charT, traits>&
     operator<< (basic_ostream<charT, traits>& out, thread::id id);
 ```
 *Effects:* Inserts an unspecified text representation of `id` into
 `out`. For two objects of type `thread::id` `x` and `y`, if `x == y` the
+`thread::id` objects have the same text representation and if `x != y`
+the `thread::id` objects have distinct text representations.
 *Returns:* `out`.
 ``` cpp
 template<> struct hash<thread::id>;
 ```
+The specialization is enabled [[unord.hash]].
+#### Constructors <a id="thread.thread.constr">[[thread.thread.constr]]</a>
 ``` cpp
 thread() noexcept;
 ```
+*Effects:* The object does not represent a thread of execution.
+*Ensures:* `get_id() == id()`.
 ``` cpp
 template<class F, class... Args> explicit thread(F&& f, Args&&... args);
 ```
+*Constraints:* `remove_cvref_t<F>` is not the same type as `thread`.
+*Mandates:* The following are all `true`:
+- `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
+- `is_move_constructible_v<decay_t<F>>`,
+- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
+- `is_invocable_v<decay_t<F>, decay_t<Args>...>`.
+*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
+*Cpp17MoveConstructible* requirements.
+*Effects:* The new thread of execution executes
+``` cpp
+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.
 [*Note 1*: This implies that any exceptions not thrown from the
 invocation of the copy of `f` will be thrown in the constructing thread,
 not the new thread. — *end note*]
+If the invocation of `invoke` terminates with an uncaught exception,
+`terminate` is called.
 *Synchronization:* The completion of the invocation of the constructor
 synchronizes with the beginning of the invocation of the copy of `f`.
+*Ensures:* `get_id() != id()`. `*this` represents the newly started
+thread.
 *Throws:* `system_error` if unable to start the new thread.
 *Error conditions:*
 ``` cpp
 thread(thread&& x) noexcept;
 ```
+*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
+`x.get_id()` prior to the start of construction.
+#### Destructor <a id="thread.thread.destr">[[thread.thread.destr]]</a>
 ``` cpp
 ~thread();
 ```
+*Effects:* If `joinable()`, calls `terminate()`. Otherwise, has no
+effects.
 [*Note 1*: Either implicitly detaching or joining a `joinable()` thread
 in its destructor could result in difficult to debug correctness (for
 detach) or performance (for join) bugs encountered only when an
 exception is thrown. Thus the programmer must ensure that the destructor
 is never executed while the thread is still joinable. — *end note*]
+#### Assignment <a id="thread.thread.assign">[[thread.thread.assign]]</a>
 ``` cpp
 thread& operator=(thread&& x) noexcept;
 ```
 *Effects:* If `joinable()`, calls `terminate()`. Otherwise, assigns the
 state of `x` to `*this` and sets `x` to a default constructed state.
+*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
+`x.get_id()` prior to the assignment.
 *Returns:* `*this`.
+#### Members <a id="thread.thread.member">[[thread.thread.member]]</a>
 ``` cpp
 void swap(thread& x) noexcept;
 ```
 ``` cpp
 void join();
 ```
+*Effects:* Blocks until the thread represented by `*this` has completed.
 *Synchronization:* The completion of the thread represented by `*this`
+synchronizes with [[intro.multithread]] the corresponding successful
 `join()` return.
 [*Note 1*: Operations on `*this` are not synchronized. — *end note*]
+*Ensures:* The thread represented by `*this` has completed.
 `get_id() == id()`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `resource_deadlock_would_occur` — if deadlock is detected or
   `get_id() == this_thread::get_id()`.
 *Effects:* The thread represented by `*this` continues execution without
 the calling thread blocking. When `detach()` returns, `*this` no longer
 represents the possibly continuing thread of execution. When the thread
 previously represented by `*this` ends execution, the implementation
+releases any owned resources.
+*Ensures:* `get_id() == id()`.
 *Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
 *Error conditions:*
 - `no_such_process` — if the thread is not valid.
 - `invalid_argument` — if the thread is not joinable.
 *Returns:* A default constructed `id` object if `*this` does not
 represent a thread, otherwise `this_thread::get_id()` for the thread of
 execution represented by `*this`.
+#### Static members <a id="thread.thread.static">[[thread.thread.static]]</a>
 ``` cpp
 unsigned hardware_concurrency() noexcept;
 ```
 *Returns:* The number of hardware thread contexts.
 [*Note 1*: This value should only be considered to be a
 hint. — *end note*]
+If this value is not computable or well-defined, an implementation
+should return 0.
+#### Specialized algorithms <a id="thread.thread.algorithm">[[thread.thread.algorithm]]</a>
 ``` cpp
 void swap(thread& x, thread& y) noexcept;
 ```
 *Effects:* As if by `x.swap(y)`.
+### Class `jthread` <a id="thread.jthread.class">[[thread.jthread.class]]</a>
+The class `jthread` provides a mechanism to create a new thread of
+execution. The functionality is the same as for class `thread`
+[[thread.thread.class]] with the additional abilities to provide a
+`stop_token` [[thread.stoptoken]] to the new thread of execution, make
+stop requests, and automatically join.
+``` cpp
+namespace std {
+  class jthread {
+  public:
+    // types
+    using id = thread::id;
+    using native_handle_type = thread::native_handle_type;
+    // [thread.jthread.cons], constructors, move, and assignment
+    jthread() noexcept;
+    template<class F, class... Args> explicit jthread(F&& f, Args&&... args);
+    ~jthread();
+    jthread(const jthread&) = delete;
+    jthread(jthread&&) noexcept;
+    jthread& operator=(const jthread&) = delete;
+    jthread& operator=(jthread&&) noexcept;
+    // [thread.jthread.mem], members
+    void swap(jthread&) noexcept;
+    [[nodiscard]] bool joinable() const noexcept;
+    void join();
+    void detach();
+    [[nodiscard]] id get_id() const noexcept;
+    [[nodiscard]] native_handle_type native_handle();   // see~[thread.req.native]
+    // [thread.jthread.stop], stop token handling
+    [[nodiscard]] stop_source get_stop_source() noexcept;
+    [[nodiscard]] stop_token get_stop_token() const noexcept;
+    bool request_stop() noexcept;
+    // [thread.jthread.special], specialized algorithms
+    friend void swap(jthread& lhs, jthread& rhs) noexcept;
+    // [thread.jthread.static], static members
+    [[nodiscard]] static unsigned int hardware_concurrency() noexcept;
+  private:
+    stop_source ssource;        // exposition only
+  };
+}
+```
+#### Constructors, move, and assignment <a id="thread.jthread.cons">[[thread.jthread.cons]]</a>
+``` cpp
+jthread() noexcept;
+```
+*Effects:* Constructs a `jthread` object that does not represent a
+thread of execution.
+*Ensures:* `get_id() == id()` is `true` and `ssource.stop_possible()` is
+`false`.
+``` cpp
+template<class F, class... Args> explicit jthread(F&& f, Args&&... args);
+```
+*Constraints:* `remove_cvref_t<F>` is not the same type as `jthread`.
+*Mandates:* The following are all `true`:
+- `is_constructible_v<decay_t<F>, F>`,
+- `(is_constructible_v<decay_t<Args>, Args> && ...)`,
+- `is_move_constructible_v<decay_t<F>>`,
+- `(is_move_constructible_v<decay_t<Args>> && ...)`, and
+- `is_invocable_v<decay_t<F>, decay_t<Args>...> ||`
+  `is_invocable_v<decay_t<F>, stop_token, decay_t<Args>...>`.
+*Preconditions:* `decay_t<F>` and each type in `decay_t<Args>` meet the
+*Cpp17MoveConstructible* requirements.
+*Effects:* Initializes `ssource`. The new thread of execution executes
+``` cpp
+invoke(decay-copy(std::forward<F>(f)), get_stop_token(),
+       decay-copy(std::forward<Args>(args))...)
+```
+if that expression is well-formed, otherwise
+``` cpp
+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.
+[*Note 1*: This implies that any exceptions not thrown from the
+invocation of the copy of `f` will be thrown in the constructing thread,
+not the new thread. — *end note*]
+If the `invoke` expression exits via an exception, `terminate` is
+called.
+*Synchronization:* The completion of the invocation of the constructor
+synchronizes with the beginning of the invocation of the copy of `f`.
+*Ensures:* `get_id() != id()` is `true` and `ssource.stop_possible()` is
+`true` and `*this` represents the newly started thread.
+[*Note 2*: The calling thread can make a stop request only once,
+because it cannot replace this stop token. — *end note*]
+*Throws:* `system_error` if unable to start the new thread.
+*Error conditions:*
+- `resource_unavailable_try_again` — the system lacked the necessary
+  resources to create another thread, or the system-imposed limit on the
+  number of threads in a process would be exceeded.
+``` cpp
+jthread(jthread&& x) noexcept;
+```
+*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
+`x.get_id()` prior to the start of construction. `ssource` has the value
+of `x.ssource` prior to the start of construction and
+`x.ssource.stop_possible()` is `false`.
+``` cpp
+~jthread();
+```
+*Effects:* If `joinable()` is `true`, calls `request_stop()` and then
+`join()`.
+[*Note 3*: Operations on `*this` are not synchronized. — *end note*]
+``` cpp
+jthread& operator=(jthread&& x) noexcept;
+```
+*Effects:* If `joinable()` is `true`, calls `request_stop()` and then
+`join()`. Assigns the state of `x` to `*this` and sets `x` to a default
+constructed state.
+*Ensures:* `x.get_id() == id()` and `get_id()` returns the value of
+`x.get_id()` prior to the assignment. `ssource` has the value of
+`x.ssource` prior to the assignment and `x.ssource.stop_possible()` is
+`false`.
+*Returns:* `*this`.
+#### Members <a id="thread.jthread.mem">[[thread.jthread.mem]]</a>
+``` cpp
+void swap(jthread& x) noexcept;
+```
+*Effects:* Exchanges the values of `*this` and `x`.
+``` cpp
+[[nodiscard]] bool joinable() const noexcept;
+```
+*Returns:* `get_id() != id()`.
+``` cpp
+void join();
+```
+*Effects:* Blocks until the thread represented by `*this` has completed.
+*Synchronization:* The completion of the thread represented by `*this`
+synchronizes with [[intro.multithread]] the corresponding successful
+`join()` return.
+[*Note 1*: Operations on `*this` are not synchronized. — *end note*]
+*Ensures:* The thread represented by `*this` has completed.
+`get_id() == id()`.
+*Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
+*Error conditions:*
+- `resource_deadlock_would_occur` — if deadlock is detected or
+  `get_id() == this_thread::get_id()`.
+- `no_such_process` — if the thread is not valid.
+- `invalid_argument` — if the thread is not joinable.
+``` cpp
+void detach();
+```
+*Effects:* The thread represented by `*this` continues execution without
+the calling thread blocking. When `detach()` returns, `*this` no longer
+represents the possibly continuing thread of execution. When the thread
+previously represented by `*this` ends execution, the implementation
+releases any owned resources.
+*Ensures:* `get_id() == id()`.
+*Throws:* `system_error` when an exception is
+required [[thread.req.exception]].
+*Error conditions:*
+- `no_such_process` — if the thread is not valid.
+- `invalid_argument` — if the thread is not joinable.
+``` cpp
+id get_id() const noexcept;
+```
+*Returns:* A default constructed `id` object if `*this` does not
+represent a thread, otherwise `this_thread::get_id()` for the thread of
+execution represented by `*this`.
+#### Stop token handling <a id="thread.jthread.stop">[[thread.jthread.stop]]</a>
+``` cpp
+[[nodiscard]] stop_source get_stop_source() noexcept;
+```
+*Effects:* Equivalent to: `return ssource;`
+``` cpp
+[[nodiscard]] stop_token get_stop_token() const noexcept;
+```
+*Effects:* Equivalent to: `return ssource.get_token();`
+``` cpp
+bool request_stop() noexcept;
+```
+*Effects:* Equivalent to: `return ssource.request_stop();`
+#### Specialized algorithms <a id="thread.jthread.special">[[thread.jthread.special]]</a>
+``` cpp
+friend void swap(jthread& x, jthread& y) noexcept;
+```
+*Effects:* Equivalent to: `x.swap(y)`.
+#### Static members <a id="thread.jthread.static">[[thread.jthread.static]]</a>
+``` cpp
+[[nodiscard]] static unsigned int hardware_concurrency() noexcept;
+```
+*Returns:* `thread::hardware_concurrency()`.
 ### Namespace `this_thread` <a id="thread.thread.this">[[thread.thread.this]]</a>
 ``` cpp
 namespace std::this_thread {
   thread::id get_id() noexcept;
 ``` cpp
 thread::id this_thread::get_id() noexcept;
 ```
 *Returns:* An object of type `thread::id` that uniquely identifies the
+current thread of execution. No other thread of execution has this id
+and this thread of execution always has this id. The object returned
+does not compare equal to a default constructed `thread::id`.
 ``` cpp
 void this_thread::yield() noexcept;
 ```
 template<class Clock, class Duration>
   void sleep_until(const chrono::time_point<Clock, Duration>& abs_time);
 ```
 *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]].

Diff to HTML by rtfpessoa