Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #ifndef __FRAMEWORK_THREADHELP_FAIRRWLOCK_HXX_
21 : #define __FRAMEWORK_THREADHELP_FAIRRWLOCK_HXX_
22 :
23 : #include <threadhelp/inoncopyable.h>
24 : #include <threadhelp/irwlock.h>
25 : #include <macros/debug.hxx>
26 :
27 : #include <com/sun/star/uno/XInterface.hpp>
28 :
29 : #include <osl/mutex.hxx>
30 : #include <osl/conditn.hxx>
31 :
32 : namespace framework{
33 :
34 : /*-************************************************************************************************************//**
35 : @short implement a read/write lock with fairness between read/write accessors
36 : @descr These implementation never should used as base class! Use it as a member every time.
37 : Use ReadGuard and/or WriteGuard in your methods (which work with these lock)
38 : to make your code threadsafe.
39 : Fair means: All reading or writing threads are synchronized AND serialzed by using one
40 : mutex. For reader this mutex is used to access internal variables of this lock only;
41 : for writer this mutex is used to have an exclusiv access on your class member!
42 : => It's a multi-reader/single-writer lock, which no preferred accessor.
43 :
44 : @implements IRWlock
45 : @base INonCopyable
46 : IRWLock
47 :
48 : @devstatus ready to use
49 : *//*-*************************************************************************************************************/
50 : class FairRWLock : public IRWLock
51 : , private INonCopyable
52 : {
53 : //-------------------------------------------------------------------------------------------------------------
54 : // public methods
55 : //-------------------------------------------------------------------------------------------------------------
56 : public:
57 :
58 : /*-****************************************************************************************************//**
59 : @short standard ctor
60 : @descr Initialize instance with right start values for correct working.
61 : no reader could exist => m_nReadCount = 0
62 : don't block first comming writer => m_aWriteCondition.set()
63 :
64 : @seealso -
65 :
66 : @param -
67 : @return -
68 :
69 : @onerror -
70 : *//*-*****************************************************************************************************/
71 0 : inline FairRWLock()
72 0 : : m_nReadCount( 0 )
73 : {
74 0 : m_aWriteCondition.set();
75 0 : }
76 :
77 0 : inline virtual ~FairRWLock()
78 0 : {
79 0 : }
80 :
81 : /*-****************************************************************************************************//**
82 : @interface IRWLock
83 : @short set lock for reading
84 : @descr A guard should call this method to acquire read access on your member.
85 : Writing isn't allowed then - but nobody could check it for you!
86 :
87 : @seealso method releaseReadAccess()
88 :
89 : @param -
90 : @return -
91 :
92 : @onerror -
93 : *//*-*****************************************************************************************************/
94 0 : inline virtual void acquireReadAccess()
95 : {
96 : // Put call in "SERIALIZE"-queue!
97 : // After successfully acquiring this mutex we are alone ...
98 0 : ::osl::MutexGuard aSerializeGuard( m_aSerializer );
99 :
100 : // ... but we should synchronize us with other reader!
101 : // May be - they will unregister himself by using releaseReadAccess()!
102 0 : ::osl::MutexGuard aAccessGuard( m_aAccessLock );
103 :
104 : // Now we must register us as reader by increasing counter.
105 : // If this the first writer we must close door for possible writer.
106 : // Other reader don't look for this barrier - they work parallel to us!
107 0 : if( m_nReadCount == 0 )
108 : {
109 0 : m_aWriteCondition.reset();
110 : }
111 0 : ++m_nReadCount;
112 0 : }
113 :
114 : /*-****************************************************************************************************//**
115 : @interface IRWLock
116 : @short reset lock for reading
117 : @descr A guard should call this method to release read access on your member.
118 :
119 : @seealso method acquireReadAccess()
120 :
121 : @param -
122 : @return -
123 :
124 : @onerror -
125 : *//*-*****************************************************************************************************/
126 0 : inline virtual void releaseReadAccess()
127 : {
128 : // The access lock is enough at this point
129 : // because it's not allowed to wait for all reader or writer here!
130 : // That will cause a deadlock!
131 0 : ::osl::MutexGuard aAccessGuard( m_aAccessLock );
132 :
133 : // Unregister as reader first!
134 : // Open writer barrier then if it was the last reader.
135 0 : --m_nReadCount;
136 0 : if( m_nReadCount == 0 )
137 : {
138 0 : m_aWriteCondition.set();
139 0 : }
140 0 : }
141 :
142 : /*-****************************************************************************************************//**
143 : @interface IRWLock
144 : @short set lock for writing
145 : @descr A guard should call this method to acquire write access on your member.
146 : Reading is allowed too - of course.
147 : After successfully calling of this method you are the only writer.
148 :
149 : @seealso method releaseWriteAccess()
150 :
151 : @param -
152 : @return -
153 :
154 : @onerror -
155 : *//*-*****************************************************************************************************/
156 0 : inline virtual void acquireWriteAccess()
157 : {
158 : // You have to stand in our serialize-queue till all reader
159 : // are registered (not for releasing them!) or writer finished their work!
160 : // Don't use a guard to do so - because you must hold the mutex till
161 : // you call releaseWriteAccess()!
162 : // After successfully acquiring you have to wait for current working reader.
163 : // Used condition will open by last gone reader object.
164 0 : m_aSerializer.acquire();
165 0 : m_aWriteCondition.wait();
166 :
167 : #ifdef ENABLE_MUTEXDEBUG
168 : // A writer is an exclusiv accessor!
169 : LOG_ASSERT2( m_nReadCount!=0, "FairRWLock::acquireWriteAccess()", "No threadsafe code detected ... : Read count != 0!" )
170 : #endif
171 0 : }
172 :
173 : /*-****************************************************************************************************//**
174 : @interface IRWLock
175 : @short reset lock for writing
176 : @descr A guard should call this method to release write access on your member.
177 :
178 : @seealso method acquireWriteAccess()
179 :
180 : @param -
181 : @return -
182 :
183 : @onerror -
184 : *//*-*****************************************************************************************************/
185 0 : inline virtual void releaseWriteAccess()
186 : {
187 : // The only one you have to do here is to release
188 : // hold seriliaze-mutex. All other user of these instance are blocked
189 : // by these mutex!
190 : // You don't need any other mutex here - you are the only one in the moment!
191 :
192 : #ifdef ENABLE_MUTEXDEBUG
193 : // A writer is an exclusiv accessor!
194 : LOG_ASSERT2( m_nReadCount!=0, "FairRWLock::releaseWriteAccess()", "No threadsafe code detected ... : Read count != 0!" )
195 : #endif
196 :
197 0 : m_aSerializer.release();
198 0 : }
199 :
200 : /*-****************************************************************************************************//**
201 : @interface IRWLock
202 : @short downgrade a write access to a read access
203 : @descr A guard should call this method to change a write to a read access.
204 : New readers can work too - new writer are blocked!
205 :
206 : @attention Don't call this method if you are not a writer!
207 : Results are not defined then ...
208 : An upgrade can't be implemented realy ... because acquiring new access
209 : will be the same - there no differences!
210 :
211 : @seealso -
212 :
213 : @param -
214 : @return -
215 :
216 : @onerror -
217 : *//*-*****************************************************************************************************/
218 0 : inline virtual void downgradeWriteAccess()
219 : {
220 : // You must be a writer to call this method!
221 : // We can't check it - but otherwise it's your problem ...
222 : // Thats why you don't need any mutex here.
223 :
224 : #ifdef ENABLE_MUTEXDEBUG
225 : // A writer is an exclusiv accessor!
226 : LOG_ASSERT2( m_nReadCount!=0, "FairRWLock::downgradeWriteAccess()", "No threadsafe code detected ... : Read count != 0!" )
227 : #endif
228 :
229 : // Register himself as "new" reader.
230 : // This value must be 0 before - because we support single writer access only!
231 0 : ++m_nReadCount;
232 : // Close barrier for other writer!
233 : // Why?
234 : // You hold the serializer mutex - next one can be a reader OR a writer.
235 : // They must blocked then - because you will be a reader after this call
236 : // and writer use this condition to wait for current reader!
237 0 : m_aWriteCondition.reset();
238 : // Open door for next waiting thread in serialize queue!
239 0 : m_aSerializer.release();
240 0 : }
241 :
242 : //-------------------------------------------------------------------------------------------------------------
243 : // private member
244 : //-------------------------------------------------------------------------------------------------------------
245 : private:
246 :
247 : ::osl::Mutex m_aAccessLock ; /// regulate access on internal member of this instance
248 : ::osl::Mutex m_aSerializer ; /// serialze incoming read/write access threads
249 : ::osl::Condition m_aWriteCondition ; /// a writer must wait till current working reader are gone
250 : sal_Int32 m_nReadCount ; /// every reader is registered - the last one open the door for waiting writer
251 :
252 : }; // class FairRWLock
253 :
254 : } // namespace framework
255 :
256 : #endif // #ifndef __FRAMEWORK_THREADHELP_FAIRRWLOCK_HXX_
257 :
258 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
