mutexes.qbk
11 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
[/
(C) Copyright 2007-8 Anthony Williams.
(C) Copyright 2013 Oliver Kowalke.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
]
[section:mutex_types Mutex Types]
[class_heading mutex]
#include <boost/fiber/mutex.hpp>
namespace boost {
namespace fibers {
class mutex {
public:
mutex();
~mutex();
mutex( mutex const& other) = delete;
mutex & operator=( mutex const& other) = delete;
void lock();
bool try_lock();
void unlock();
};
}}
__mutex__ provides an exclusive-ownership mutex. At most one fiber can own the
lock on a given instance of __mutex__ at any time. Multiple concurrent calls to
__lock__, __try_lock__ and __unlock__ shall be permitted.
Any fiber blocked in __lock__ is suspended until the owning fiber releases the
lock by calling __unlock__.
[member_heading mutex..lock]
void lock();
[variablelist
[[Precondition:] [The calling fiber doesn't own the mutex.]]
[[Effects:] [The current fiber blocks until ownership can be obtained.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]]
]
[member_heading mutex..try_lock]
bool try_lock();
[variablelist
[[Precondition:] [The calling fiber doesn't own the mutex.]]
[[Effects:] [Attempt to obtain ownership for the current fiber without
blocking.]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]]
]
[member_heading mutex..unlock]
void unlock();
[variablelist
[[Precondition:] [The current fiber owns `*this`.]]
[[Effects:] [Releases a lock on `*this` by the current fiber.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]]
]
[class_heading timed_mutex]
#include <boost/fiber/timed_mutex.hpp>
namespace boost {
namespace fibers {
class timed_mutex {
public:
timed_mutex();
~timed_mutex();
timed_mutex( timed_mutex const& other) = delete;
timed_mutex & operator=( timed_mutex const& other) = delete;
void lock();
bool try_lock();
void unlock();
template< typename Clock, typename Duration >
bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);
template< typename Rep, typename Period >
bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);
};
}}
__timed_mutex__ provides an exclusive-ownership mutex. At most one fiber can own
the lock on a given instance of __timed_mutex__ at any time. Multiple concurrent
calls to __lock__, __try_lock__, __try_lock_until__, __try_lock_for__ and
__unlock__ shall be permitted.
[member_heading timed_mutex..lock]
void lock();
[variablelist
[[Precondition:] [The calling fiber doesn't own the mutex.]]
[[Effects:] [The current fiber blocks until ownership can be obtained.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]]
]
[member_heading timed_mutex..try_lock]
bool try_lock();
[variablelist
[[Precondition:] [The calling fiber doesn't own the mutex.]]
[[Effects:] [Attempt to obtain ownership for the current fiber without
blocking.]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]]
]
[member_heading timed_mutex..unlock]
void unlock();
[variablelist
[[Precondition:] [The current fiber owns `*this`.]]
[[Effects:] [Releases a lock on `*this` by the current fiber.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]]
]
[template_member_heading timed_mutex..try_lock_until]
template< typename Clock, typename Duration >
bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);
[variablelist
[[Precondition:] [The calling fiber doesn't own the mutex.]]
[[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until
ownership can be obtained, or the specified time is reached. If the specified
time has already passed, behaves as [member_link timed_mutex..try_lock].]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [`lock_error`, timeout-related exceptions.]]
[[Error Conditions:] [
[*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]]
]
[template_member_heading timed_mutex..try_lock_for]
template< typename Rep, typename Period >
bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);
[variablelist
[[Precondition:] [The calling fiber doesn't own the mutex.]]
[[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until
ownership can be obtained, or the specified time is reached. If the specified
time has already passed, behaves as [member_link timed_mutex..try_lock].]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [`lock_error`, timeout-related exceptions.]]
[[Error Conditions:] [
[*resource_deadlock_would_occur]: if `boost::this_fiber::get_id()` already owns the mutex.]]
]
[class_heading recursive_mutex]
#include <boost/fiber/recursive_mutex.hpp>
namespace boost {
namespace fibers {
class recursive_mutex {
public:
recursive_mutex();
~recursive_mutex();
recursive_mutex( recursive_mutex const& other) = delete;
recursive_mutex & operator=( recursive_mutex const& other) = delete;
void lock();
bool try_lock() noexcept;
void unlock();
};
}}
__recursive_mutex__ provides an exclusive-ownership recursive mutex. At most one
fiber can own the lock on a given instance of __recursive_mutex__ at any time.
Multiple concurrent calls to __lock__, __try_lock__ and __unlock__ shall be
permitted. A fiber that already has exclusive ownership of a given
__recursive_mutex__ instance can call __lock__ or __try_lock__ to acquire an
additional level of ownership of the mutex. __unlock__ must be called once for
each level of ownership acquired by a single fiber before ownership can be
acquired by another fiber.
[member_heading recursive_mutex..lock]
void lock();
[variablelist
[[Effects:] [The current fiber blocks until ownership can be obtained.]]
[[Throws:] [Nothing]]
]
[member_heading recursive_mutex..try_lock]
bool try_lock() noexcept;
[variablelist
[[Effects:] [Attempt to obtain ownership for the current fiber without
blocking.]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [Nothing.]]
]
[member_heading recursive_mutex..unlock]
void unlock();
[variablelist
[[Effects:] [Releases a lock on `*this` by the current fiber.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]]
]
[class_heading recursive_timed_mutex]
#include <boost/fiber/recursive_timed_mutex.hpp>
namespace boost {
namespace fibers {
class recursive_timed_mutex {
public:
recursive_timed_mutex();
~recursive_timed_mutex();
recursive_timed_mutex( recursive_timed_mutex const& other) = delete;
recursive_timed_mutex & operator=( recursive_timed_mutex const& other) = delete;
void lock();
bool try_lock() noexcept;
void unlock();
template< typename Clock, typename Duration >
bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);
template< typename Rep, typename Period >
bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);
};
}}
__recursive_timed_mutex__ provides an exclusive-ownership recursive mutex. At
most one fiber can own the lock on a given instance of
__recursive_timed_mutex__ at any time. Multiple concurrent calls to __lock__,
__try_lock__, __try_lock_for__, __try_lock_until__ and __unlock__ shall be
permitted. A fiber that already has exclusive ownership of a given
__recursive_timed_mutex__ instance can call __lock__, __try_lock__,
__try_lock_for__ or __try_lock_until__ to acquire an additional level of
ownership of the mutex. __unlock__ must be called once for each level of
ownership acquired by a single fiber before ownership can be acquired by another
fiber.
[member_heading recursive_timed_mutex..lock]
void lock();
[variablelist
[[Effects:] [The current fiber blocks until ownership can be obtained.]]
[[Throws:] [Nothing]]
]
[member_heading recursive_timed_mutex..try_lock]
bool try_lock() noexcept;
[variablelist
[[Effects:] [Attempt to obtain ownership for the current fiber without
blocking.]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [Nothing.]]
]
[member_heading recursive_timed_mutex..unlock]
void unlock();
[variablelist
[[Effects:] [Releases a lock on `*this` by the current fiber.]]
[[Throws:] [`lock_error`]]
[[Error Conditions:] [
[*operation_not_permitted]: if `boost::this_fiber::get_id()` does not own the mutex.]]
]
[template_member_heading recursive_timed_mutex..try_lock_until]
template< typename Clock, typename Duration >
bool try_lock_until( std::chrono::time_point< Clock, Duration > const& timeout_time);
[variablelist
[[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until
ownership can be obtained, or the specified time is reached. If the specified
time has already passed, behaves as [member_link recursive_timed_mutex..try_lock].]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [Timeout-related exceptions.]]
]
[template_member_heading recursive_timed_mutex..try_lock_for]
template< typename Rep, typename Period >
bool try_lock_for( std::chrono::duration< Rep, Period > const& timeout_duration);
[variablelist
[[Effects:] [Attempt to obtain ownership for the current fiber. Blocks until
ownership can be obtained, or the specified time is reached. If the specified
time has already passed, behaves as [member_link recursive_timed_mutex..try_lock].]]
[[Returns:] [`true` if ownership was obtained for the current fiber, `false`
otherwise.]]
[[Throws:] [Timeout-related exceptions.]]
]
[endsect]