hpx::jthread

Defined in header hpx/jthread.hpp.

See Public API for a list of names and headers that are part of the public HPX API.

namespace hpx

Functions

inline HPX_CXX_EXPORT void swap (jthread &lhs, jthread &rhs) noexcept

class jthread

#include <jthread.hpp>

The class jthread represents a single thread of execution. It has the same general behavior as hpx::thread, except that jthread automatically rejoins on destruction, and can be cancelled/stopped in certain situations. Threads begin execution immediately upon construction of the associated thread object (pending any OS scheduling delays), starting at the top-level function provided as a constructor argument. The return value of the top-level function is ignored and if it terminates by throwing an exception, hpx::terminate is called. The top-level function may communicate its return value or an exception to the caller via hpx::promise or by modifying shared variables (which may require synchronization, see hpx::mutex and hpx::atomic) Unlike hpx::thread, the jthread logically holds an internal private member of type hpx::stop_source, which maintains a shared stop-state. The jthread constructor accepts a function that takes a hpx::stop_token as its first argument, which will be passed in by the jthread from its internal stop_source. This allows the function to check if stop has been requested during its execution, and return if it has. hpx::jthread objects may also be in the state that does not represent any thread (after default construction, move from, detach, or join), and a thread of execution may be not associated with any jthread objects (after detach). No two hpx::jthread objects may represent the same thread of execution; hpx::jthread is not CopyConstructible or CopyAssignable, although it is MoveConstructible and MoveAssignable.

Public Types

using id = thread::id

using native_handle_type = thread::native_handle_type

Public Functions

inline jthread() noexcept

template<typename F, typename... Ts>  requires (!std::is_same_v< std::decay_t< F >, jthread >) explicit jthread(F &&f

jthread(jthread &&x) noexcept = default

jthread &operator=(jthread const&) = delete

jthread &operator=(jthread&&) noexcept = default

moves the jthread object

inline void swap(jthread &t) noexcept

swaps two jthread objects

inline bool joinable() const noexcept

checks whether the thread is joinable, i.e. potentially running in parallel context

inline void join()

waits for the thread to finish its execution

inline void detach()

permits the thread to execute independently of the thread handle

inline id get_id() const noexcept

returns the id of the thread

inline native_handle_type native_handle() const

returns the underlying implementation-defined thread handle

inline stop_source get_stop_source() noexcept

returns a stop_source object associated with the shared stop state of the thread

inline stop_token get_stop_token() const noexcept

returns a stop_token associated with the shared stop state of the thread

inline bool request_stop() const noexcept

requests execution stop via the shared stop state of the thread

Public Members

Ts &&ts

Ts thread_  {[](stop_token st, F&& f, Ts&&... ts) -> void {using use_stop_token =typename is_invocable<F, stop_token, Ts...>::type;jthread::invoke(use_stop_token{}, HPX_FORWARD(F, f),HPX_MOVE(st), HPX_FORWARD(Ts, ts)...);},ssource_.get_token(), HPX_FORWARD(F, f),HPX_FORWARD(Ts, ts)...}{}~jthread(){if (joinable()){request_stop();                 join();}}jthread(jthread const&) = delete

Public Static Functions

static inline unsigned int hardware_concurrency() noexcept

returns the number of concurrent threads supported by the implementation

Private Members

stop_source ssource_

hpx::thread thread_ = {}

Private Static Functions

template<typename F, typename ...Ts>
static inline void invoke(std::false_type, F &&f, stop_token&&, Ts&&... ts)

template<typename F, typename ...Ts>
static inline void invoke(std::true_type, F &&f, stop_token &&st, Ts&&... ts)