ceph/src/boost/libs/thread/doc/thread.qbk

   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.7.2]
  12     [authors [Williams, Anthony] [Botet Escriba, Vicente J.]]
  13     [copyright 2007-11 Anthony Williams]
  14     [copyright 2011-16 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]