|
|
|
1 |
|
/*** |
2 |
|
*lock.h |
3 |
|
* |
4 |
|
* Copyright (c) Microsoft Corporation. All rights reserved. |
5 |
|
* |
6 |
|
*Purpose: lock class for automatically acquiring/releasing |
7 |
|
* the monitor lock on managed types. |
8 |
|
* |
9 |
|
* [Public] |
10 |
|
* |
11 |
|
****/ |
12 |
|
|
13 |
|
#pragma once |
14 |
|
|
15 |
|
#if !defined(_INC_MSCLR_LOCK) |
16 |
|
|
17 |
|
#ifndef __cplusplus_cli |
18 |
|
#error ERROR: msclr libraries are not compatible with /clr:oldSyntax |
19 |
|
#endif |
20 |
|
|
21 |
|
#using <mscorlib.dll> |
22 |
|
#include <msclr\safebool.h> |
23 |
|
#if !defined(_M_CEE_SAFE) |
24 |
|
#include <vcclr.h> |
25 |
|
#endif |
26 |
|
|
27 |
|
namespace msclr |
28 |
|
{ |
29 |
|
|
30 |
|
// The lock_when enumeration is used to defer the lock object |
31 |
|
// from taking the lock. |
32 |
|
enum lock_when { lock_later }; |
33 |
|
|
34 |
|
ref class lock |
35 |
|
{ |
36 |
|
private: |
37 |
|
System::Object ^ m_object; |
38 |
|
bool m_locked; |
39 |
|
|
40 |
|
template<class T,class U> value struct is_not { typedef int __dont_use_this_type__; }; |
41 |
|
template<class T> value struct is_not<T,T> { }; |
42 |
|
|
43 |
|
public: |
44 |
|
// By default, take the lock immediately with an infinite timeout. |
45 |
|
// Accept an optional timespan (in milliseconds) and throw on failure or timeout. |
46 |
|
template<class T> lock( T ^ _object) |
47 |
|
: m_object( _object ), |
48 |
|
m_locked( false ) |
49 |
|
{ |
50 |
|
// ensure that T is not a ReaderWriterLock. |
51 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
52 |
|
(_Diagnostic); |
53 |
|
|
54 |
|
acquire(System::Threading::Timeout::Infinite); |
55 |
|
} |
56 |
|
|
57 |
|
template<class T> lock( T ^ _object, int _timeout ) |
58 |
|
: m_object( _object ), |
59 |
|
m_locked( false ) |
60 |
|
{ |
61 |
|
// ensure that T is not a ReaderWriterLock. |
62 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
63 |
|
(_Diagnostic); |
64 |
|
|
65 |
|
acquire( _timeout ); |
66 |
|
} |
67 |
|
|
68 |
|
// By default, take the lock immediately within the specified timespan |
69 |
|
// and throw on failure or timeout. |
70 |
|
template<class T> lock( T ^ _object, System::TimeSpan _timeout ) |
71 |
|
: m_object( _object ), |
72 |
|
m_locked( false ) |
73 |
|
{ |
74 |
|
// ensure that T is not a ReaderWriterLock. |
75 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
76 |
|
(_Diagnostic); |
77 |
|
|
78 |
|
acquire( _timeout ); |
79 |
|
} |
80 |
|
|
81 |
|
// If you use the "lock_later" enumeration, it causes lock |
82 |
|
// to defer taking the lock. |
83 |
|
template<class T> lock( T ^ _object, lock_when ) |
84 |
|
: m_object( _object ), |
85 |
|
m_locked( false ) |
86 |
|
{ |
87 |
|
// ensure that T is not a ReaderWriterLock. |
88 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
89 |
|
(_Diagnostic); |
90 |
|
} |
91 |
|
|
92 |
|
#if !defined(_M_CEE_SAFE) |
93 |
|
template<class T> lock( gcroot<T ^> _object) |
94 |
|
: m_object( _object ), |
95 |
|
m_locked( false ) |
96 |
|
{ |
97 |
|
// ensure that T is not a ReaderWriterLock. |
98 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
99 |
|
(_Diagnostic); |
100 |
|
|
101 |
|
acquire(System::Threading::Timeout::Infinite); |
102 |
|
} |
103 |
|
|
104 |
|
|
105 |
|
template<class T> lock( gcroot<T ^> _object, int _timeout ) |
106 |
|
: m_object( _object ), |
107 |
|
m_locked( false ) |
108 |
|
{ |
109 |
|
// ensure that T is not a ReaderWriterLock. |
110 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
111 |
|
(_Diagnostic); |
112 |
|
|
113 |
|
acquire( _timeout ); |
114 |
|
} |
115 |
|
|
116 |
|
// By default, take the lock immediately within the specified timespan |
117 |
|
// and throw on failure or timeout. |
118 |
|
template<class T> lock( gcroot<T ^> _object, System::TimeSpan _timeout ) |
119 |
|
: m_object( _object ), |
120 |
|
m_locked( false ) |
121 |
|
{ |
122 |
|
// ensure that T is not a ReaderWriterLock. |
123 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
124 |
|
(_Diagnostic); |
125 |
|
|
126 |
|
acquire( _timeout ); |
127 |
|
} |
128 |
|
|
129 |
|
// If you use the "lock_later" enumeration, it causes lock |
130 |
|
// to defer taking the lock. |
131 |
|
template<class T> lock( gcroot<T ^> _object, lock_when ) |
132 |
|
: m_object( _object ), |
133 |
|
m_locked( false ) |
134 |
|
{ |
135 |
|
// ensure that T is not a ReaderWriterLock. |
136 |
|
is_not<T, System::Threading::ReaderWriterLock>::__dont_use_this_type__ _Diagnostic; |
137 |
|
(_Diagnostic); |
138 |
|
} |
139 |
|
#endif /* if !defined(_M_CEE_SAFE) */ |
140 |
|
|
141 |
|
// release the lock if it is not currently held |
142 |
|
~lock() |
143 |
|
{ |
144 |
|
release(); |
145 |
|
} |
146 |
|
|
147 |
|
// Check to see if this lock object is currently holding the lock |
148 |
|
bool is_locked() |
149 |
|
{ |
150 |
|
return m_locked; |
151 |
|
} |
152 |
|
|
153 |
|
// Check to see if this lock object is currently holding the lock |
154 |
|
operator _detail_class::_safe_bool() |
155 |
|
{ |
156 |
|
return is_locked() ? _detail_class::_safe_true : _detail_class::_safe_false; |
157 |
|
} |
158 |
|
|
159 |
|
// disallow explicit comparisons to _safe_bool |
160 |
|
template<class T> bool operator==( T t ) |
161 |
|
{ |
162 |
|
// ensure that T is not a _safe_bool. |
163 |
|
is_not<T, _detail_class::_safe_bool>::__dont_use_this_type__ _Diagnostic; |
164 |
|
(_Diagnostic); |
165 |
|
|
166 |
|
return m_object == t; |
167 |
|
} |
168 |
|
|
169 |
|
template<class T> bool operator!=( T t ) |
170 |
|
{ |
171 |
|
// ensure that T is not a _safe_bool. |
182 |
|
if( ! m_locked ) |
183 |
|
{ |
184 |
|
if( ! System::Threading::Monitor::TryEnter( m_object, _timeout ) ) |
185 |
|
{ |
186 |
|
throw gcnew System::ApplicationException( "lock timeout" ); |
187 |
|
} |
188 |
|
m_locked = true; |
189 |
|
} |
190 |
|
} |
191 |
|
|
192 |
|
void acquire() |
193 |
|
{ |
194 |
|
if( ! m_locked ) |
195 |
|
{ |
196 |
|
if( ! System::Threading::Monitor::TryEnter( m_object, |
197 |
|
System::Threading::Timeout::Infinite ) ) |
198 |
|
{ |
199 |
|
throw gcnew System::ApplicationException( "lock timeout" ); |
200 |
|
} |
201 |
|
m_locked = true; |
202 |
|
} |
203 |
|
} |
204 |
|
|
205 |
|
// Take the lock within the specified timespan. |
206 |
|
// Throw an ApplicationException on timeout. |
207 |
|
void acquire( System::TimeSpan _timeout ) |
208 |
|
{ |
209 |
|
if( ! m_locked ) |
210 |
|
{ |
211 |
|
if( ! System::Threading::Monitor::TryEnter( m_object, _timeout ) ) |
212 |
|
{ |
213 |
|
throw gcnew System::ApplicationException( "lock timeout" ); |
214 |
|
} |
215 |
|
m_locked = true; |
216 |
|
} |
217 |
|
} |
218 |
|
|
219 |
|
// Try to take the lock within the specified timespan. In the case |
220 |
|
// of timeout, return false. |
221 |
|
bool try_acquire( int _timeout ) // throw() |
222 |
|
{ |
223 |
|
if( ! m_locked ) |
224 |
|
{ |
225 |
|
if( ! System::Threading::Monitor::TryEnter( m_object, _timeout ) ) |
226 |
|
{ |
227 |
|
return false; |
228 |
|
} |
229 |
|
m_locked = true; |
230 |
|
} |
231 |
|
return true; |
232 |
|
} |
233 |
|
|
234 |
|
// Try to take the lock within the specified timespan. In the case |
235 |
|
// of timeout, return false. |
236 |
|
bool try_acquire( System::TimeSpan _timeout ) // throw() |
237 |
|
{ |
238 |
|
if( ! m_locked ) |
239 |
|
{ |
240 |
|
if( ! System::Threading::Monitor::TryEnter( m_object, _timeout ) ) |
241 |
|
{ |
242 |
|
return false; |
243 |
|
} |
244 |
|
m_locked = true; |
245 |
|
} |
246 |
|
return true; |
247 |
|
} |
248 |
|
|
249 |
|
// Release the lock if it is currently held |
250 |
|
void release() |
251 |
|
{ |
252 |
|
if( m_locked ) |
253 |
|
{ |
254 |
|
m_locked = false; |
255 |
|
System::Threading::Monitor::Exit( m_object ); |
256 |
|
} |
257 |
|
} |
258 |
|
}; |
259 |
|
} |
260 |
|
|
261 |
|
#define _INC_MSCLR_LOCK |
262 |
|
|
263 |
|
#endif // _INC_MSCLR_LOCK |
264 |
|
|
|
|
|