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

namespace hpx


inline 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, typename Enable = typename std::enable_if<!std::is_same<typename std::decay<F>::type, jthread>::value>::type>
inline explicit jthread(F &&f, Ts&&... ts)#
inline ~jthread()#
jthread(jthread const&) = delete#
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 from the thread handle

inline id get_id() const noexcept#

returns the id of the thread

inline native_handle_type native_handle()#

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() noexcept#

requests execution stop via the shared stop state of the thread

Public Static Functions

static inline unsigned int hardware_concurrency()#

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)#