2 //===---------------------- condition_variable ----------------------------===//
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
8 //===----------------------------------------------------------------------===//
10 #ifndef _LIBCPP_CONDITION_VARIABLE
11 #define _LIBCPP_CONDITION_VARIABLE
14 condition_variable synopsis
19 enum class cv_status { no_timeout, timeout };
21 class condition_variable
25 ~condition_variable();
27 condition_variable(const condition_variable&) = delete;
28 condition_variable& operator=(const condition_variable&) = delete;
30 void notify_one() noexcept;
31 void notify_all() noexcept;
33 void wait(unique_lock<mutex>& lock);
34 template <class Predicate>
35 void wait(unique_lock<mutex>& lock, Predicate pred);
37 template <class Clock, class Duration>
39 wait_until(unique_lock<mutex>& lock,
40 const chrono::time_point<Clock, Duration>& abs_time);
42 template <class Clock, class Duration, class Predicate>
44 wait_until(unique_lock<mutex>& lock,
45 const chrono::time_point<Clock, Duration>& abs_time,
48 template <class Rep, class Period>
50 wait_for(unique_lock<mutex>& lock,
51 const chrono::duration<Rep, Period>& rel_time);
53 template <class Rep, class Period, class Predicate>
55 wait_for(unique_lock<mutex>& lock,
56 const chrono::duration<Rep, Period>& rel_time,
59 typedef pthread_cond_t* native_handle_type;
60 native_handle_type native_handle();
63 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
65 class condition_variable_any
68 condition_variable_any();
69 ~condition_variable_any();
71 condition_variable_any(const condition_variable_any&) = delete;
72 condition_variable_any& operator=(const condition_variable_any&) = delete;
74 void notify_one() noexcept;
75 void notify_all() noexcept;
78 void wait(Lock& lock);
79 template <class Lock, class Predicate>
80 void wait(Lock& lock, Predicate pred);
82 template <class Lock, class Clock, class Duration>
84 wait_until(Lock& lock,
85 const chrono::time_point<Clock, Duration>& abs_time);
87 template <class Lock, class Clock, class Duration, class Predicate>
89 wait_until(Lock& lock,
90 const chrono::time_point<Clock, Duration>& abs_time,
93 template <class Lock, class Rep, class Period>
96 const chrono::duration<Rep, Period>& rel_time);
98 template <class Lock, class Rep, class Period, class Predicate>
101 const chrono::duration<Rep, Period>& rel_time,
110 #include <__mutex_base>
113 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
114 #pragma GCC system_header
117 #ifndef _LIBCPP_HAS_NO_THREADS
119 _LIBCPP_BEGIN_NAMESPACE_STD
121 class _LIBCPP_TYPE_VIS condition_variable_any
123 condition_variable __cv_;
124 shared_ptr<mutex> __mut_;
126 _LIBCPP_INLINE_VISIBILITY
127 condition_variable_any();
129 _LIBCPP_INLINE_VISIBILITY
130 void notify_one() _NOEXCEPT;
131 _LIBCPP_INLINE_VISIBILITY
132 void notify_all() _NOEXCEPT;
134 template <class _Lock>
135 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
136 void wait(_Lock& __lock);
137 template <class _Lock, class _Predicate>
138 _LIBCPP_INLINE_VISIBILITY
139 void wait(_Lock& __lock, _Predicate __pred);
141 template <class _Lock, class _Clock, class _Duration>
142 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
144 wait_until(_Lock& __lock,
145 const chrono::time_point<_Clock, _Duration>& __t);
147 template <class _Lock, class _Clock, class _Duration, class _Predicate>
149 _LIBCPP_INLINE_VISIBILITY
150 wait_until(_Lock& __lock,
151 const chrono::time_point<_Clock, _Duration>& __t,
154 template <class _Lock, class _Rep, class _Period>
156 _LIBCPP_INLINE_VISIBILITY
157 wait_for(_Lock& __lock,
158 const chrono::duration<_Rep, _Period>& __d);
160 template <class _Lock, class _Rep, class _Period, class _Predicate>
162 _LIBCPP_INLINE_VISIBILITY
163 wait_for(_Lock& __lock,
164 const chrono::duration<_Rep, _Period>& __d,
169 condition_variable_any::condition_variable_any()
170 : __mut_(make_shared<mutex>()) {}
174 condition_variable_any::notify_one() _NOEXCEPT
176 {lock_guard<mutex> __lx(*__mut_);}
182 condition_variable_any::notify_all() _NOEXCEPT
184 {lock_guard<mutex> __lx(*__mut_);}
188 struct __lock_external
190 template <class _Lock>
191 void operator()(_Lock* __m) {__m->lock();}
194 template <class _Lock>
196 condition_variable_any::wait(_Lock& __lock)
198 shared_ptr<mutex> __mut = __mut_;
199 unique_lock<mutex> __lk(*__mut);
201 unique_ptr<_Lock, __lock_external> __lxx(&__lock);
202 lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
204 } // __mut_.unlock(), __lock.lock()
206 template <class _Lock, class _Predicate>
209 condition_variable_any::wait(_Lock& __lock, _Predicate __pred)
215 template <class _Lock, class _Clock, class _Duration>
217 condition_variable_any::wait_until(_Lock& __lock,
218 const chrono::time_point<_Clock, _Duration>& __t)
220 shared_ptr<mutex> __mut = __mut_;
221 unique_lock<mutex> __lk(*__mut);
223 unique_ptr<_Lock, __lock_external> __lxx(&__lock);
224 lock_guard<unique_lock<mutex> > __lx(__lk, adopt_lock);
225 return __cv_.wait_until(__lk, __t);
226 } // __mut_.unlock(), __lock.lock()
228 template <class _Lock, class _Clock, class _Duration, class _Predicate>
231 condition_variable_any::wait_until(_Lock& __lock,
232 const chrono::time_point<_Clock, _Duration>& __t,
236 if (wait_until(__lock, __t) == cv_status::timeout)
241 template <class _Lock, class _Rep, class _Period>
244 condition_variable_any::wait_for(_Lock& __lock,
245 const chrono::duration<_Rep, _Period>& __d)
247 return wait_until(__lock, chrono::steady_clock::now() + __d);
250 template <class _Lock, class _Rep, class _Period, class _Predicate>
253 condition_variable_any::wait_for(_Lock& __lock,
254 const chrono::duration<_Rep, _Period>& __d,
257 return wait_until(__lock, chrono::steady_clock::now() + __d,
258 _VSTD::move(__pred));
262 void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
264 _LIBCPP_END_NAMESPACE_STD
266 #endif // !_LIBCPP_HAS_NO_THREADS
268 #endif // _LIBCPP_CONDITION_VARIABLE