1[/
2  (C) Copyright 2008-11 Anthony Williams
3  (C) Copyright 2011-12 Vicente J. Botet Escriba
4  Distributed under the Boost Software License, Version 1.0.
5  (See accompanying file LICENSE_1_0.txt or copy at
6  http://www.boost.org/LICENSE_1_0.txt).
7]
8
9[library Thread
10    [quickbook 1.5]
11    [version 4.8.0]
12    [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
13    [copyright 2007-11 Anthony Williams]
14    [copyright 2011-17 Vicente J. Botet Escriba]
15    [purpose C++ Library for launching threads and synchronizing data between them]
16    [category text]
17    [license
18        Distributed under the Boost Software License, Version 1.0.
19        (See accompanying file LICENSE_1_0.txt or copy at
20        [@http://www.boost.org/LICENSE_1_0.txt])
21    ]
22]
23
24[template lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.lockable [link_text]]]
25[def __lockable_concept__ [lockable_concept_link `Lockable` concept]]
26[def __lockable_concept_type__ [lockable_concept_link `Lockable`]]
27[def __BasicLockable [link thread.synchronization.mutex_concepts.basic_lockable `BasicLockable`]]
28[def __Lockable [link thread.synchronization.mutex_concepts.lockable `Lockable`]]
29[def __TimedLockable [link thread.synchronization.mutex_concepts.timed_lockable `TimedLockable`]]
30[def __SharedLockable [link thread.synchronization.mutex_concepts.shared_lockable `SharedLockable`]]
31[def __UpgradeLockable [link thread.synchronization.mutex_concepts.upgrade_lockable `UpgradeLockable`]]
32
33[template timed_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable [link_text]]]
34[def __timed_lockable_concept__ [timed_lockable_concept_link `TimedLockable` concept]]
35[def __timed_lockable_concept_type__ [timed_lockable_concept_link `TimedLockable`]]
36
37[template shared_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable [link_text]]]
38[def __shared_lockable_concept__ [shared_lockable_concept_link `SharedLockable` concept]]
39[def __shared_lockable_concept_type__ [shared_lockable_concept_link `SharedLockable`]]
40
41[template upgrade_lockable_concept_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable [link_text]]]
42[def __upgrade_lockable_concept__ [upgrade_lockable_concept_link `UpgradeLockable` concept]]
43[def __upgrade_lockable_concept_type__ [upgrade_lockable_concept_link `UpgradeLockable`]]
44
45
46[template lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.basic_lockable.lock [link_text]]]
47[def __lock_ref__ [lock_ref_link `lock()`]]
48[def __lock [link thread.synchronization.mutex_concepts.basic_lockable.lock `lock`]]
49
50[template lock_multiple_ref_link[link_text] [link thread.synchronization.lock_functions.lock_multiple [link_text]]]
51[def __lock_multiple_ref__ [lock_multiple_ref_link `lock()`]]
52
53[template try_lock_multiple_ref_link[link_text] [link thread.synchronization.lock_functions.try_lock_multiple [link_text]]]
54[def __try_lock_multiple_ref__ [try_lock_multiple_ref_link `try_lock()`]]
55
56[template unlock_ref_link[link_text] [link thread.synchronization.mutex_concepts.basic_lockable.unlock [link_text]]]
57[def __unlock_ref__ [unlock_ref_link `unlock()`]]
58[def __unlock [link thread.synchronization.mutex_concepts.basic_lockable.unlock `unlock`]]
59
60[template try_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.lockable.try_lock [link_text]]]
61[def __try_lock_ref__ [try_lock_ref_link `try_lock()`]]
62[def __try_lock [link thread.synchronization.mutex_concepts.lockable.try_lock `try_lock`]]
63
64[template timed_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock [link_text]]]
65[def __timed_lock_ref__ [timed_lock_ref_link `timed_lock()`]]
66[def __timed_lock [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock `timed_lock`]]
67
68[def __try_lock_for [link thread.synchronization.mutex_concepts.timed_lockable.try_lock_for `try_lock_for`]]
69[def __try_lock_until [link thread.synchronization.mutex_concepts.timed_lockable.try_lock_until `try_lock_until`]]
70
71[template timed_lock_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock_duration [link_text]]]
72[def __timed_lock_duration_ref__ [timed_lock_duration_ref_link `timed_lock()`]]
73[def __timed_lock_duration [link thread.synchronization.mutex_concepts.timed_lockable.timed_lock_duration `timed_lock`]]
74
75[template lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.lock_shared [link_text]]]
76[def __lock_shared_ref__ [lock_shared_ref_link `lock_shared()`]]
77[def __lock_shared [link thread.synchronization.mutex_concepts.shared_lockable.lock_shared  `lock_shared()`]]
78
79[template unlock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.unlock_shared [link_text]]]
80[def __unlock_shared_ref__ [unlock_shared_ref_link `unlock_shared()`]]
81[def __unlock_shared [link thread.synchronization.mutex_concepts.shared_lockable.unlock_shared  `unlock_shared()`]]
82
83[template try_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared [link_text]]]
84[def __try_lock_shared_ref__ [try_lock_shared_ref_link `try_lock_shared()`]]
85[def __try_lock_shared [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared `try_lock_shared`]]
86
87[template timed_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.timed_lock_shared [link_text]]]
88[def __timed_lock_shared_ref__ [timed_lock_shared_ref_link `timed_lock_shared()`]]
89[def __try_lock_shared_for [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared_for `try_lock_shared_for`]]
90[def __try_lock_shared_for [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared_until `try_lock_shared_until`]]
91
92[template timed_lock_shared_duration_ref_link[link_text] [link thread.synchronization.mutex_concepts.shared_lockable.timed_lock_shared_duration [link_text]]]
93[def __timed_lock_shared_duration_ref__ [timed_lock_shared_duration_ref_link `timed_lock_shared()`]]
94[def __try_lock_shared_for [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared_for `try_lock_shared_for`]]
95[def __try_lock_shared_until [link thread.synchronization.mutex_concepts.shared_lockable.try_lock_shared_until `try_lock_shared_until`]]
96
97[template lock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.lock_upgrade [link_text]]]
98[def __lock_upgrade_ref__ [lock_upgrade_ref_link `lock_upgrade()`]]
99[def __lock_upgrade [link thread.synchronization.mutex_concepts.upgrade_lockable.lock_upgrade `lock_upgrade`]]
100[def __try_lock_upgrade [link thread.synchronization.mutex_concepts.upgrade_lockable.try_lock_upgrade `try_lock_upgrade`]]
101[def __try_lock_upgrade_for [link thread.synchronization.mutex_concepts.upgrade_lockable.try_lock_upgrade_for `try_lock_upgrade_for`]]
102[def __try_lock_upgrade_until [link thread.synchronization.mutex_concepts.upgrade_lockable.try_lock_upgrade_until `try_lock_upgrade_until`]]
103
104[template unlock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade [link_text]]]
105[def __unlock_upgrade_ref__ [unlock_upgrade_ref_link `unlock_upgrade()`]]
106[def __unlock_upgrade [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade `unlock_upgrade`]]
107
108[template unlock_upgrade_and_lock_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock [link_text]]]
109[def __unlock_upgrade_and_lock_ref__ [unlock_upgrade_and_lock_ref_link `unlock_upgrade_and_lock()`]]
110[def __unlock_upgrade_and_lock [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock `unlock_upgrade_and_lock`]]
111
112[template unlock_and_lock_upgrade_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_and_lock_upgrade [link_text]]]
113[def __unlock_and_lock_upgrade_ref__ [unlock_and_lock_upgrade_ref_link `unlock_and_lock_upgrade()`]]
114[def __unlock_and_lock_upgrade [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_and_lock_upgrade `unlock_and_lock_upgrade`]]
115
116[template unlock_upgrade_and_lock_shared_ref_link[link_text] [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock_shared [link_text]]]
117[def __unlock_upgrade_and_lock_shared_ref__ [unlock_upgrade_and_lock_shared_ref_link `unlock_upgrade_and_lock_shared()`]]
118[def __unlock_upgrade_and_lock_shared [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_upgrade_and_lock_shared `unlock_upgrade_and_lock_shared`]]
119
120
121[def __try_unlock_shared_and_lock [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_shared_and_lock `try_unlock_shared_and_lock`]]
122[def __try_unlock_shared_and_lock_for [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_shared_and_lock_for `try_unlock_shared_and_lock_for`]]
123[def __try_unlock_shared_and_lock_until [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_shared_and_lock_until `try_unlock_shared_and_lock_until`]]
124
125[def __unlock_and_lock_shared [link thread.synchronization.mutex_concepts.upgrade_lockable.unlock_and_lock_shared `unlock_and_lock_shared`]]
126
127[def __try_unlock_shared_and_lock_upgrade [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_shared_and_lock_upgrade `try_unlock_shared_and_lock_upgrade`]]
128[def __try_unlock_shared_and_lock_upgrade_for [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_shared_and_lock_upgrade_for `try_unlock_shared_and_lock_upgrade_for`]]
129[def __try_unlock_shared_and_lock_upgrade_until [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_shared_and_lock_upgrade_until `try_unlock_shared_and_lock_upgrade_until`]]
130
131[def __try_unlock_upgrade_and_lock [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_upgrade_and_lock `try_unlock_upgrade_and_lock`]]
132[def __try_unlock_upgrade_and_lock_for [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_upgrade_and_lock_for `try_unlock_upgrade_and_lock_for`]]
133[def __try_unlock_upgrade_and_lock_until [link thread.synchronization.mutex_concepts.upgrade_lockable.try_unlock_upgrade_and_lock_until `try_unlock_upgrade_and_lock_until`]]
134
135
136[template owns_lock_ref_link[link_text] [link thread.synchronization.locks.unique_lock.owns_lock [link_text]]]
137[def __owns_lock_ref__ [owns_lock_ref_link `owns_lock()`]]
138[def __owns_lock [owns_lock_ref_link `owns_lock()`]]
139
140[template owns_lock_shared_ref_link[link_text] [link thread.synchronization.locks.shared_lock.owns_lock [link_text]]]
141[def __owns_lock_shared_ref__ [owns_lock_shared_ref_link `owns_lock()`]]
142
143[template mutex_func_ref_link[link_text] [link thread.synchronization.locks.unique_lock.mutex [link_text]]]
144[def __mutex_func_ref__ [mutex_func_ref_link `mutex()`]]
145
146[def __boost_thread__ [*Boost.Thread]]
147[def __not_a_thread__ ['Not-a-Thread]]
148[def __interruption_points__ [link interruption_points ['interruption points]]]
149[def __lock_error__ `lock_error`]
150
151[def __mutex__ [link thread.synchronization.mutex_types.mutex `boost::mutex`]]
152[def __try_mutex__ [link thread.synchronization.mutex_types.try_mutex `boost::try_mutex`]]
153[def __timed_mutex__ [link thread.synchronization.mutex_types.timed_mutex `boost::timed_mutex`]]
154[def __recursive_mutex__ [link thread.synchronization.mutex_types.recursive_mutex `boost::recursive_mutex`]]
155[def __recursive_try_mutex__ [link thread.synchronization.mutex_types.recursive_try_mutex `boost::recursive_try_mutex`]]
156[def __recursive_timed_mutex__ [link thread.synchronization.mutex_types.recursive_timed_mutex `boost::recursive_timed_mutex`]]
157[def __shared_mutex__ [link thread.synchronization.mutex_types.shared_mutex `boost::shared_mutex`]]
158
159
160[def __StrictLock [link thread.synchronization.lock_concepts.StrictLock `StrictLock`]]
161
162[template unique_lock_link[link_text] [link thread.synchronization.locks.unique_lock [link_text]]]
163
164[def __lock_guard__ [link thread.synchronization.lock_guard.lock_guard `boost::lock_guard`]]
165[def __unique_lock__ [unique_lock_link `boost::unique_lock`]]
166[def __unique_lock [unique_lock_link `boost::unique_lock`]]
167[def __shared_lock__ [link thread.synchronization.locks.shared_lock `boost::shared_lock`]]
168[def __upgrade_lock__ [link thread.synchronization.locks.upgrade_lock `boost::upgrade_lock`]]
169[def __upgrade_to_unique_lock__ [link thread.synchronization.locks.upgrade_to_unique_lock `boost::upgrade_to_unique_lock`]]
170[def __reverse_lock [link thread.synchronization.other_locks.reverse_lock `reverse_lock`]]
171[def __shared_lock_guard [link thread.synchronization.other_locks.shared_lock_guard `shared_lock_guard`]]
172[def __shared_lock_guard_constructor_adopt [link thread.synchronization.other_locks.shared_lock_guard `shared_lock_guard`]]
173
174[def __strict_lock [link thread.synchronization.other_locks.strict_locks.strict_lock `strict_lock`]]
175[def __nested_strict_lock [link thread.synchronization.other_locks.strict_locks.nested_strict_lock `nested_strict_lock`]]
176
177
178[def __thread__ [link thread.thread_management.thread `boost::thread`]]
179[def __thread [link thread.thread_management.thread `thread`]]
180[def __thread_id__ [link thread.thread_management.thread.id `boost::thread::id`]]
181[template join_link[link_text] [link thread.thread_management.thread.join [link_text]]]
182[def __join__ [join_link `join()`]]
183
184[def __try_join_for [link thread.thread_management.thread.try_join_for `try_join_for`]]
185[def __try_join_until [link thread.thread_management.thread.try_join_until `try_join_until`]]
186
187[template timed_join_link[link_text] [link thread.thread_management.thread.timed_join [link_text]]]
188[def __timed_join__ [timed_join_link `timed_join()`]]
189[def __detach__ [link thread.thread_management.thread.detach `detach()`]]
190[def __interrupt__ [link thread.thread_management.thread.interrupt `interrupt()`]]
191[def __sleep__ [link thread.thread_management.this_thread.sleep `boost::this_thread::sleep()`]]
192[def __sleep_for [link thread.thread_management.this_thread.sleep_for `sleep_for`]]
193[def __sleep_until [link thread.thread_management.this_thread.sleep_until `sleep_until`]]
194[def __yield [link thread.thread_management.this_thread.yield `yield`]]
195[def __get_id [link thread.thread_management.thread.get_id `get_id`]]
196
197[def __interruption_enabled__ [link thread.thread_management.this_thread.interruption_enabled `boost::this_thread::interruption_enabled()`]]
198[def __interruption_requested__ [link thread.thread_management.this_thread.interruption_requested `boost::this_thread::interruption_requested()`]]
199[def __interruption_point__ [link thread.thread_management.this_thread.interruption_point `boost::this_thread::interruption_point()`]]
200[def __disable_interruption__ [link thread.thread_management.this_thread.disable_interruption `boost::this_thread::disable_interruption`]]
201[def __restore_interruption__ [link thread.thread_management.this_thread.restore_interruption `boost::this_thread::restore_interruption`]]
202
203[def __thread_resource_error__ `boost::thread_resource_error`]
204[def __thread_interrupted__ `boost::thread_interrupted`]
205[def __barrier__ [link thread.synchronization.barriers.barrier `boost::barrier`]]
206[def __latch__   [link thread.synchronization.latches.latch `latch`]]
207
208[template cond_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.wait [link_text]]]
209[def __cond_wait__ [cond_wait_link `wait()`]]
210[template cond_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable.timed_wait [link_text]]]
211[def __cond_timed_wait__ [cond_timed_wait_link `timed_wait()`]]
212
213[def __condition_variable [link thread.synchronization.condvar_ref.condition_variable `condition_variable`]]
214[def __wait_for [link thread.synchronization.condvar_ref.condition_variable.wait_for `wait_for`]]
215[def __wait_until [link thread.synchronization.condvar_ref.condition_variable.wait_until `wait_until`]]
216
217
218[template cond_any_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.wait [link_text]]]
219[def __cond_any_wait__ [cond_any_wait_link `wait()`]]
220[template cond_any_timed_wait_link[link_text] [link thread.synchronization.condvar_ref.condition_variable_any.timed_wait [link_text]]]
221[def __cond_any_timed_wait__ [cond_any_timed_wait_link `timed_wait()`]]
222
223[def __condition_variable_any [link thread.synchronization.condvar_ref.condition_variable_any `condition_variable_any`]]
224[def __cvany_wait_for [link thread.synchronization.condvar_ref.condition_variable_any.wait_for `wait_for`]]
225[def __cvany_wait_until [link thread.synchronization.condvar_ref.condition_variable_any.wait_until `wait_until`]]
226
227[def __blocked__ ['blocked]]
228
229[include overview.qbk]
230[include changes.qbk]
231
232[include thread_ref.qbk]
233[include scoped_thread.qbk]
234
235[section:synchronization Synchronization]
236[include sync_tutorial.qbk]
237[include mutex_concepts.qbk]
238[include mutexes.qbk]
239[include condition_variables.qbk]
240[include once.qbk]
241[include barrier.qbk]
242[include latch.qbk]
243[include async_executors.qbk]
244[include futures.qbk]
245[endsect]
246
247[include tss.qbk]
248
249[section:sds Synchronized Data Structures]
250[include synchronized_value.qbk]
251[include sync_queues_ref.qbk]
252[/include sync_streams.qbk]
253[endsect]
254
255[include parallel.qbk]
256
257[include time.qbk]
258
259[include emulations.qbk]
260
261[include acknowledgements.qbk]
262
263[include compliance.qbk]
264