libstdc++

thread
Go to the documentation of this file.
1 // <thread> -*- C++ -*-
2
3 // Copyright (C) 2008-2013 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24
25 /** @file include/thread
26 * This is a Standard C++ Library header.
27 */
28
29 #ifndef _GLIBCXX_THREAD
30 #define _GLIBCXX_THREAD 1
31
32 #pragma GCC system_header
33
34 #if __cplusplus < 201103L
35 # include <bits/c++0x_warning.h>
36 #else
37
38 #include <chrono>
39 #include <functional>
40 #include <memory>
41 #include <bits/functexcept.h>
42 #include <bits/functional_hash.h>
43 #include <bits/gthr.h>
44
45 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
46
47 namespace std _GLIBCXX_VISIBILITY(default)
48 {
49 _GLIBCXX_BEGIN_NAMESPACE_VERSION
50
51 /**
52 * @defgroup threads Threads
53 * @ingroup concurrency
54 *
55 * Classes for thread support.
56 * @{
57 */
58
59 /// thread
60 class thread
61 {
62 public:
63 typedef __gthread_t native_handle_type;
64 struct _Impl_base;
65 typedef shared_ptr<_Impl_base> __shared_base_type;
66
67 /// thread::id
68 class id
69 {
70 native_handle_type _M_thread;
71
72 public:
73 id() noexcept : _M_thread() { }
74
75 explicit
76 id(native_handle_type __id) : _M_thread(__id) { }
77
78 private:
79 friend class thread;
80 friend class hash<thread::id>;
81
82 friend bool
83 operator==(thread::id __x, thread::id __y) noexcept
84 { return __gthread_equal(__x._M_thread, __y._M_thread); }
85
86 friend bool
87 operator<(thread::id __x, thread::id __y) noexcept
88 { return __x._M_thread < __y._M_thread; }
89
90 template<class _CharT, class _Traits>
91 friend basic_ostream<_CharT, _Traits>&
92 operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
93 };
94
95 // Simple base type that the templatized, derived class containing
96 // an arbitrary functor can be converted to and called.
97 struct _Impl_base
98 {
99 __shared_base_type _M_this_ptr;
100
101 inline virtual ~_Impl_base();
102
103 virtual void _M_run() = 0;
104 };
105
106 template<typename _Callable>
107 struct _Impl : public _Impl_base
108 {
109 _Callable _M_func;
110
111 _Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
112 { }
113
114 void
115 _M_run() { _M_func(); }
116 };
117
118 private:
119 id _M_id;
120
121 public:
122 thread() noexcept = default;
123 // _GLIBCXX_RESOLVE_LIB_DEFECTS
124 // 2097. packaged_task constructors should be constrained
125 thread(thread&) = delete;
126 thread(const thread&) = delete;
127
128 thread(thread&& __t) noexcept
129 { swap(__t); }
130
131 template<typename _Callable, typename... _Args>
132 explicit
133 thread(_Callable&& __f, _Args&&... __args)
134 {
135 _M_start_thread(_M_make_routine(std::__bind_simple(
136 std::forward<_Callable>(__f),
137 std::forward<_Args>(__args)...)));
138 }
139
140 ~thread()
141 {
142 if (joinable())
143 std::terminate();
144 }
145
146 thread& operator=(const thread&) = delete;
147
148 thread& operator=(thread&& __t) noexcept
149 {
150 if (joinable())
151 std::terminate();
152 swap(__t);
153 return *this;
154 }
155
156 void
157 swap(thread& __t) noexcept
158 { std::swap(_M_id, __t._M_id); }
159
160 bool
161 joinable() const noexcept
162 { return !(_M_id == id()); }
163
164 void
165 join();
166
167 void
168 detach();
169
170 thread::id
171 get_id() const noexcept
172 { return _M_id; }
173
174 /** @pre thread is joinable
175 */
176 native_handle_type
177 native_handle()
178 { return _M_id._M_thread; }
179
180 // Returns a value that hints at the number of hardware thread contexts.
181 static unsigned int
182 hardware_concurrency() noexcept;
183
184 private:
185 void
186 _M_start_thread(__shared_base_type);
187
188 template<typename _Callable>
189 shared_ptr<_Impl<_Callable>>
190 _M_make_routine(_Callable&& __f)
191 {
192 // Create and allocate full data structure, not base.
193 return std::make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f));
194 }
195 };
196
197 inline thread::_Impl_base::~_Impl_base() = default;
198
199 inline void
200 swap(thread& __x, thread& __y) noexcept
201 { __x.swap(__y); }
202
203 inline bool
204 operator!=(thread::id __x, thread::id __y) noexcept
205 { return !(__x == __y); }
206
207 inline bool
208 operator<=(thread::id __x, thread::id __y) noexcept
209 { return !(__y < __x); }
210
211 inline bool
212 operator>(thread::id __x, thread::id __y) noexcept
213 { return __y < __x; }
214
215 inline bool
216 operator>=(thread::id __x, thread::id __y) noexcept
217 { return !(__x < __y); }
218
219 // DR 889.
220 /// std::hash specialization for thread::id.
221 template<>
222 struct hash<thread::id>
223 : public __hash_base<size_t, thread::id>
224 {
225 size_t
226 operator()(const thread::id& __id) const noexcept
227 { return std::_Hash_impl::hash(__id._M_thread); }
228 };
229
230 template<class _CharT, class _Traits>
231 inline basic_ostream<_CharT, _Traits>&
232 operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
233 {
234 if (__id == thread::id())
235 return __out << "thread::id of a non-executing thread";
236 else
237 return __out << __id._M_thread;
238 }
239
240 _GLIBCXX_END_NAMESPACE_VERSION
241
242 /** @namespace std::this_thread
243 * @brief ISO C++ 2011 entities sub-namespace for thread.
244 * 30.3.2 Namespace this_thread.
245 */
246 namespace this_thread
247 {
248 _GLIBCXX_BEGIN_NAMESPACE_VERSION
249
250 /// get_id
251 inline thread::id
252 get_id() noexcept { return thread::id(__gthread_self()); }
253
254 /// yield
255 inline void
256 yield() noexcept
257 {
258 #ifdef _GLIBCXX_USE_SCHED_YIELD
259 __gthread_yield();
260 #endif
261 }
262
263 void
264 __sleep_for(chrono::seconds, chrono::nanoseconds);
265
266 /// sleep_for
267 template<typename _Rep, typename _Period>
268 inline void
269 sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
270 {
271 auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
272 auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
273 #ifdef _GLIBCXX_USE_NANOSLEEP
274 __gthread_time_t __ts =
275 {
276 static_cast<std::time_t>(__s.count()),
277 static_cast<long>(__ns.count())
278 };
279 ::nanosleep(&__ts, 0);
280 #else
281 __sleep_for(__s, __ns);
282 #endif
283 }
284
285 /// sleep_until
286 template<typename _Clock, typename _Duration>
287 inline void
288 sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
289 { sleep_for(__atime - _Clock::now()); }
290
291 _GLIBCXX_END_NAMESPACE_VERSION
292 }
293
294 // @} group threads
295
296 } // namespace
297
298 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
299
300 #endif // C++11
301
302 #endif // _GLIBCXX_THREAD