1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP___THREAD_JTHREAD_H 11 #define _LIBCPP___THREAD_JTHREAD_H 12 13 #include <__config> 14 #include <__stop_token/stop_source.h> 15 #include <__stop_token/stop_token.h> 16 #include <__thread/id.h> 17 #include <__thread/support.h> 18 #include <__thread/thread.h> 19 #include <__type_traits/decay.h> 20 #include <__type_traits/invoke.h> 21 #include <__type_traits/is_constructible.h> 22 #include <__type_traits/is_same.h> 23 #include <__type_traits/remove_cvref.h> 24 #include <__utility/forward.h> 25 #include <__utility/move.h> 26 #include <__utility/swap.h> 27 28 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 29 # pragma GCC system_header 30 #endif 31 32 _LIBCPP_PUSH_MACROS 33 #include <__undef_macros> 34 35 #if _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS 36 37 _LIBCPP_BEGIN_NAMESPACE_STD 38 39 class _LIBCPP_AVAILABILITY_SYNC jthread { 40 public: 41 // types 42 using id = thread::id; 43 using native_handle_type = thread::native_handle_type; 44 45 // [thread.jthread.cons], constructors, move, and assignment 46 _LIBCPP_HIDE_FROM_ABI jthread() noexcept : __stop_source_(std::nostopstate) {} 47 48 template <class _Fun, class... _Args> 49 _LIBCPP_HIDE_FROM_ABI explicit jthread(_Fun&& __fun, _Args&&... __args) 50 requires(!std::is_same_v<remove_cvref_t<_Fun>, jthread>) 51 : __stop_source_(), 52 __thread_(__init_thread(__stop_source_, std::forward<_Fun>(__fun), std::forward<_Args>(__args)...)) { 53 static_assert(is_constructible_v<decay_t<_Fun>, _Fun>); 54 static_assert((is_constructible_v<decay_t<_Args>, _Args> && ...)); 55 static_assert(is_invocable_v<decay_t<_Fun>, decay_t<_Args>...> || 56 is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>); 57 } 58 59 _LIBCPP_HIDE_FROM_ABI ~jthread() { 60 if (joinable()) { 61 request_stop(); 62 join(); 63 } 64 } 65 66 jthread(const jthread&) = delete; 67 68 _LIBCPP_HIDE_FROM_ABI jthread(jthread&&) noexcept = default; 69 70 jthread& operator=(const jthread&) = delete; 71 72 _LIBCPP_HIDE_FROM_ABI jthread& operator=(jthread&& __other) noexcept { 73 if (this != &__other) { 74 if (joinable()) { 75 request_stop(); 76 join(); 77 } 78 __stop_source_ = std::move(__other.__stop_source_); 79 __thread_ = std::move(__other.__thread_); 80 } 81 82 return *this; 83 } 84 85 // [thread.jthread.mem], members 86 _LIBCPP_HIDE_FROM_ABI void swap(jthread& __other) noexcept { 87 std::swap(__stop_source_, __other.__stop_source_); 88 std::swap(__thread_, __other.__thread_); 89 } 90 91 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool joinable() const noexcept { return get_id() != id(); } 92 93 _LIBCPP_HIDE_FROM_ABI void join() { __thread_.join(); } 94 95 _LIBCPP_HIDE_FROM_ABI void detach() { __thread_.detach(); } 96 97 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI id get_id() const noexcept { return __thread_.get_id(); } 98 99 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return __thread_.native_handle(); } 100 101 // [thread.jthread.stop], stop token handling 102 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_source get_stop_source() noexcept { return __stop_source_; } 103 104 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_token get_stop_token() const noexcept { return __stop_source_.get_token(); } 105 106 _LIBCPP_HIDE_FROM_ABI bool request_stop() noexcept { return __stop_source_.request_stop(); } 107 108 // [thread.jthread.special], specialized algorithms 109 _LIBCPP_HIDE_FROM_ABI friend void swap(jthread& __lhs, jthread& __rhs) noexcept { __lhs.swap(__rhs); } 110 111 // [thread.jthread.static], static members 112 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static unsigned int hardware_concurrency() noexcept { 113 return thread::hardware_concurrency(); 114 } 115 116 private: 117 template <class _Fun, class... _Args> 118 _LIBCPP_HIDE_FROM_ABI static thread __init_thread(const stop_source& __ss, _Fun&& __fun, _Args&&... __args) { 119 if constexpr (is_invocable_v<decay_t<_Fun>, stop_token, decay_t<_Args>...>) { 120 return thread(std::forward<_Fun>(__fun), __ss.get_token(), std::forward<_Args>(__args)...); 121 } else { 122 return thread(std::forward<_Fun>(__fun), std::forward<_Args>(__args)...); 123 } 124 } 125 126 stop_source __stop_source_; 127 thread __thread_; 128 }; 129 130 _LIBCPP_END_NAMESPACE_STD 131 132 #endif // _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS 133 134 _LIBCPP_POP_MACROS 135 136 #endif // _LIBCPP___THREAD_JTHREAD_H 137