libstdc++
thread
Go to the documentation of this file.
1 // <thread> -*- C++ -*-
2 
3 // Copyright (C) 2008-2016 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 <memory>
40 #include <tuple>
41 #include <cerrno>
42 #include <bits/functexcept.h>
43 #include <bits/functional_hash.h>
44 #include <bits/invoke.h>
45 #include <bits/gthr.h>
46 
47 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
48 
49 namespace std _GLIBCXX_VISIBILITY(default)
50 {
51 _GLIBCXX_BEGIN_NAMESPACE_VERSION
52 
53  /**
54  * @defgroup threads Threads
55  * @ingroup concurrency
56  *
57  * Classes for thread support.
58  * @{
59  */
60 
61  /// thread
62  class thread
63  {
64  public:
65  // Abstract base class for types that wrap arbitrary functors to be
66  // invoked in the new thread of execution.
67  struct _State
68  {
69  virtual ~_State();
70  virtual void _M_run() = 0;
71  };
73 
74  typedef __gthread_t native_handle_type;
75 
76  /// thread::id
77  class id
78  {
79  native_handle_type _M_thread;
80 
81  public:
82  id() noexcept : _M_thread() { }
83 
84  explicit
85  id(native_handle_type __id) : _M_thread(__id) { }
86 
87  private:
88  friend class thread;
89  friend class hash<thread::id>;
90 
91  friend bool
92  operator==(thread::id __x, thread::id __y) noexcept;
93 
94  friend bool
95  operator<(thread::id __x, thread::id __y) noexcept;
96 
97  template<class _CharT, class _Traits>
98  friend basic_ostream<_CharT, _Traits>&
99  operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
100  };
101 
102  private:
103  id _M_id;
104 
105  public:
106  thread() noexcept = default;
107  // _GLIBCXX_RESOLVE_LIB_DEFECTS
108  // 2097. packaged_task constructors should be constrained
109  thread(thread&) = delete;
110  thread(const thread&) = delete;
111 
112  thread(thread&& __t) noexcept
113  { swap(__t); }
114 
115  template<typename _Callable, typename... _Args>
116  explicit
117  thread(_Callable&& __f, _Args&&... __args)
118  {
119 #ifdef GTHR_ACTIVE_PROXY
120  // Create a reference to pthread_create, not just the gthr weak symbol.
121  auto __depend = reinterpret_cast<void(*)()>(&pthread_create);
122 #else
123  auto __depend = nullptr;
124 #endif
125  _M_start_thread(_S_make_state(
126  __make_invoker(std::forward<_Callable>(__f),
127  std::forward<_Args>(__args)...)),
128  __depend);
129  }
130 
131  ~thread()
132  {
133  if (joinable())
134  std::terminate();
135  }
136 
137  thread& operator=(const thread&) = delete;
138 
139  thread& operator=(thread&& __t) noexcept
140  {
141  if (joinable())
142  std::terminate();
143  swap(__t);
144  return *this;
145  }
146 
147  void
148  swap(thread& __t) noexcept
149  { std::swap(_M_id, __t._M_id); }
150 
151  bool
152  joinable() const noexcept
153  { return !(_M_id == id()); }
154 
155  void
156  join();
157 
158  void
159  detach();
160 
161  thread::id
162  get_id() const noexcept
163  { return _M_id; }
164 
165  /** @pre thread is joinable
166  */
167  native_handle_type
168  native_handle()
169  { return _M_id._M_thread; }
170 
171  // Returns a value that hints at the number of hardware thread contexts.
172  static unsigned int
173  hardware_concurrency() noexcept;
174 
175  private:
176  template<typename _Callable>
177  struct _State_impl : public _State
178  {
179  _Callable _M_func;
180 
181  _State_impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
182  { }
183 
184  void
185  _M_run() { _M_func(); }
186  };
187 
188  void
189  _M_start_thread(_State_ptr, void (*)());
190 
191  template<typename _Callable>
192  static _State_ptr
193  _S_make_state(_Callable&& __f)
194  {
195  using _Impl = _State_impl<_Callable>;
196  return _State_ptr{new _Impl{std::forward<_Callable>(__f)}};
197  }
198 #if _GLIBCXX_THREAD_ABI_COMPAT
199  public:
200  struct _Impl_base;
201  typedef shared_ptr<_Impl_base> __shared_base_type;
202  struct _Impl_base
203  {
204  __shared_base_type _M_this_ptr;
205  virtual ~_Impl_base() = default;
206  virtual void _M_run() = 0;
207  };
208 
209  private:
210  void
211  _M_start_thread(__shared_base_type, void (*)());
212 
213  void
214  _M_start_thread(__shared_base_type);
215 #endif
216 
217  private:
218  // A call wrapper that does INVOKE(forwarded tuple elements...)
219  template<typename _Tuple>
220  struct _Invoker
221  {
222  _Tuple _M_t;
223 
224  template<size_t _Index>
225  static __tuple_element_t<_Index, _Tuple>&&
226  _S_declval();
227 
228  template<size_t... _Ind>
229  auto
230  _M_invoke(_Index_tuple<_Ind...>)
231  noexcept(noexcept(std::__invoke(_S_declval<_Ind>()...)))
232  -> decltype(std::__invoke(_S_declval<_Ind>()...))
233  { return std::__invoke(std::get<_Ind>(std::move(_M_t))...); }
234 
235  using _Indices
236  = typename _Build_index_tuple<tuple_size<_Tuple>::value>::__type;
237 
238  auto
239  operator()()
240  noexcept(noexcept(std::declval<_Invoker&>()._M_invoke(_Indices())))
241  -> decltype(std::declval<_Invoker&>()._M_invoke(_Indices()))
242  { return _M_invoke(_Indices()); }
243  };
244 
245  // Alias for _Invoker<tuple<DECAY_COPY(_Tp)...>>
246  template<typename... _Tp>
247  using __invoker_type
248  = _Invoker<decltype(std::make_tuple(std::declval<_Tp>()...))>;
249 
250  public:
251  // Returns a call wrapper that does
252  // INVOKE(DECAY_COPY(__callable), DECAY_COPY(__args)).
253  template<typename _Callable, typename... _Args>
254  static __invoker_type<_Callable, _Args...>
255  __make_invoker(_Callable&& __callable, _Args&&... __args)
256  {
257  return { {
258  std::make_tuple(std::forward<_Callable>(__callable),
259  std::forward<_Args>(__args)...)
260  } };
261  }
262  };
263 
264  inline void
265  swap(thread& __x, thread& __y) noexcept
266  { __x.swap(__y); }
267 
268  inline bool
269  operator==(thread::id __x, thread::id __y) noexcept
270  {
271  // pthread_equal is undefined if either thread ID is not valid, so we
272  // can't safely use __gthread_equal on default-constructed values (nor
273  // the non-zero value returned by this_thread::get_id() for
274  // single-threaded programs using GNU libc). Assume EqualityComparable.
275  return __x._M_thread == __y._M_thread;
276  }
277 
278  inline bool
279  operator!=(thread::id __x, thread::id __y) noexcept
280  { return !(__x == __y); }
281 
282  inline bool
283  operator<(thread::id __x, thread::id __y) noexcept
284  {
285  // Pthreads doesn't define any way to do this, so we just have to
286  // assume native_handle_type is LessThanComparable.
287  return __x._M_thread < __y._M_thread;
288  }
289 
290  inline bool
291  operator<=(thread::id __x, thread::id __y) noexcept
292  { return !(__y < __x); }
293 
294  inline bool
295  operator>(thread::id __x, thread::id __y) noexcept
296  { return __y < __x; }
297 
298  inline bool
299  operator>=(thread::id __x, thread::id __y) noexcept
300  { return !(__x < __y); }
301 
302  // DR 889.
303  /// std::hash specialization for thread::id.
304  template<>
305  struct hash<thread::id>
306  : public __hash_base<size_t, thread::id>
307  {
308  size_t
309  operator()(const thread::id& __id) const noexcept
310  { return std::_Hash_impl::hash(__id._M_thread); }
311  };
312 
313  template<class _CharT, class _Traits>
314  inline basic_ostream<_CharT, _Traits>&
315  operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
316  {
317  if (__id == thread::id())
318  return __out << "thread::id of a non-executing thread";
319  else
320  return __out << __id._M_thread;
321  }
322 
323 _GLIBCXX_END_NAMESPACE_VERSION
324 
325  /** @namespace std::this_thread
326  * @brief ISO C++ 2011 entities sub-namespace for thread.
327  * 30.3.2 Namespace this_thread.
328  */
329  namespace this_thread
330  {
331  _GLIBCXX_BEGIN_NAMESPACE_VERSION
332 
333  /// get_id
334  inline thread::id
335  get_id() noexcept
336  {
337 #ifdef __GLIBC__
338  // For the GNU C library pthread_self() is usable without linking to
339  // libpthread.so but returns 0, so we cannot use it in single-threaded
340  // programs, because this_thread::get_id() != thread::id{} must be true.
341  // We know that pthread_t is an integral type in the GNU C library.
342  if (!__gthread_active_p())
343  return thread::id(1);
344 #endif
345  return thread::id(__gthread_self());
346  }
347 
348  /// yield
349  inline void
350  yield() noexcept
351  {
352 #ifdef _GLIBCXX_USE_SCHED_YIELD
353  __gthread_yield();
354 #endif
355  }
356 
357  void
358  __sleep_for(chrono::seconds, chrono::nanoseconds);
359 
360  /// sleep_for
361  template<typename _Rep, typename _Period>
362  inline void
363  sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
364  {
365  if (__rtime <= __rtime.zero())
366  return;
367  auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
368  auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
369 #ifdef _GLIBCXX_USE_NANOSLEEP
370  __gthread_time_t __ts =
371  {
372  static_cast<std::time_t>(__s.count()),
373  static_cast<long>(__ns.count())
374  };
375  while (::nanosleep(&__ts, &__ts) == -1 && errno == EINTR)
376  { }
377 #else
378  __sleep_for(__s, __ns);
379 #endif
380  }
381 
382  /// sleep_until
383  template<typename _Clock, typename _Duration>
384  inline void
385  sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
386  {
387  auto __now = _Clock::now();
388  if (_Clock::is_steady)
389  {
390  if (__now < __atime)
391  sleep_for(__atime - __now);
392  return;
393  }
394  while (__now < __atime)
395  {
396  sleep_for(__atime - __now);
397  __now = _Clock::now();
398  }
399  }
400 
401  _GLIBCXX_END_NAMESPACE_VERSION
402  }
403 
404  // @} group threads
405 
406 } // namespace
407 
408 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
409 
410 #endif // C++11
411 
412 #endif // _GLIBCXX_THREAD
Primary class template hash.
Definition: system_error:141
thread
Definition: thread:62
ISO C++ entities toplevel namespace is std.
thread::id
Definition: thread:77
20.7.1.2 unique_ptr for single objects.
Definition: unique_ptr.h:153