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