Java > Open Source Codes > org > logicalcobwebs > concurrent > WriterPreferenceReadWriteLock


1 /*
2   File: WriterPreferenceReadWriteLock.java
3
4   Originally written by Doug Lea and released into the public domain.
5   This may be used for any purposes whatsoever without acknowledgment.
6   Thanks for the assistance and support of Sun Microsystems Labs,
7   and everyone contributing, testing, and using this code.
8
9   History:
10   Date Who What
11   11Jun1998 dl Create public version
12    5Aug1998 dl replaced int counters with longs
13   25aug1998 dl record writer thread
14    3May1999 dl add notifications on interrupt/timeout
15
16 */
17
18 package org.logicalcobwebs.concurrent;
19
20 /**
21  * A ReadWriteLock that prefers waiting writers over
22  * waiting readers when there is contention. This class
23  * is adapted from the versions described in CPJ, improving
24  * on the ones there a bit by segregating reader and writer
25  * wait queues, which is typically more efficient.
26  * <p>
27  * The locks are <em>NOT</em> reentrant. In particular,
28  * even though it may appear to usually work OK,
29  * a thread holding a read lock should not attempt to
30  * re-acquire it. Doing so risks lockouts when there are
31  * also waiting writers.
32  * <p>[<a HREF="http://gee.cs.oswego.edu/dl/classes/EDU/oswego/cs/dl/util/concurrent/intro.html"> Introduction to this package. </a>]
33  **/
34
35 public class WriterPreferenceReadWriteLock implements ReadWriteLock {
36
37     protected long activeReaders_ = 0;
38     protected Thread activeWriter_ = null;
39     protected long waitingReaders_ = 0;
40     protected long waitingWriters_ = 0;
41
42
43     protected final ReaderLock readerLock_ = new ReaderLock();
44     protected final WriterLock writerLock_ = new WriterLock();
45
46     public Sync writeLock() {
47         return writerLock_;
48     }
49
50     public Sync readLock() {
51         return readerLock_;
52     }
53
54     /*
55       A bunch of small synchronized methods are needed
56       to allow communication from the Lock objects
57       back to this object, that serves as controller
58     */
59
60
61     protected synchronized void cancelledWaitingReader() {
62         --waitingReaders_;
63     }
64
65     protected synchronized void cancelledWaitingWriter() {
66         --waitingWriters_;
67     }
68
69
70     /** Override this method to change to reader preference **/
71     protected boolean allowReader() {
72         return activeWriter_ == null && waitingWriters_ == 0;
73     }
74
75
76     protected synchronized boolean startRead() {
77         boolean allowRead = allowReader();
78         if (allowRead) ++activeReaders_;
79         return allowRead;
80     }
81
82     protected synchronized boolean startWrite() {
83
84         // The allowWrite expression cannot be modified without
85 // also changing startWrite, so is hard-wired
86
87         boolean allowWrite = (activeWriter_ == null && activeReaders_ == 0);
88         if (allowWrite) activeWriter_ = Thread.currentThread();
89         return allowWrite;
90     }
91
92
93     /*
94        Each of these variants is needed to maintain atomicity
95        of wait counts during wait loops. They could be
96        made faster by manually inlining each other. We hope that
97        compilers do this for us though.
98     */
99
100     protected synchronized boolean startReadFromNewReader() {
101         boolean pass = startRead();
102         if (!pass) ++waitingReaders_;
103         return pass;
104     }
105
106     protected synchronized boolean startWriteFromNewWriter() {
107         boolean pass = startWrite();
108         if (!pass) ++waitingWriters_;
109         return pass;
110     }
111
112     protected synchronized boolean startReadFromWaitingReader() {
113         boolean pass = startRead();
114         if (pass) --waitingReaders_;
115         return pass;
116     }
117
118     protected synchronized boolean startWriteFromWaitingWriter() {
119         boolean pass = startWrite();
120         if (pass) --waitingWriters_;
121         return pass;
122     }
123
124     /**
125      * Called upon termination of a read.
126      * Returns the object to signal to wake up a waiter, or null if no such
127      **/
128     protected synchronized Signaller endRead() {
129         if (--activeReaders_ == 0 && waitingWriters_ > 0)
130             return writerLock_;
131         else
132             return null;
133     }
134
135
136     /**
137      * Called upon termination of a write.
138      * Returns the object to signal to wake up a waiter, or null if no such
139      **/
140     protected synchronized Signaller endWrite() {
141         activeWriter_ = null;
142         if (waitingReaders_ > 0 && allowReader())
143             return readerLock_;
144         else if (waitingWriters_ > 0)
145             return writerLock_;
146         else
147             return null;
148     }
149
150
151     /**
152      * Reader and Writer requests are maintained in two different
153      * wait sets, by two different objects. These objects do not
154      * know whether the wait sets need notification since they
155      * don't know preference rules. So, each supports a
156      * method that can be selected by main controlling object
157      * to perform the notifications. This base class simplifies mechanics.
158      **/
159
160     protected abstract class Signaller { // base for ReaderLock and WriterLock
161 abstract void signalWaiters();
162     }
163
164     protected class ReaderLock extends Signaller implements Sync {
165
166         public void acquire() throws InterruptedException {
167             if (Thread.interrupted()) throw new InterruptedException ();
168             InterruptedException ie = null;
169             synchronized (this) {
170                 if (!startReadFromNewReader()) {
171                     for (; ;) {
172                         try {
173                             ReaderLock.this.wait();
174                             if (startReadFromWaitingReader())
175                                 return;
176                         } catch (InterruptedException ex) {
177                             cancelledWaitingReader();
178                             ie = ex;
179                             break;
180                         }
181                     }
182                 }
183             }
184             if (ie != null) {
185                 // fall through outside synch on interrupt.
186 // This notification is not really needed here,
187 // but may be in plausible subclasses
188 writerLock_.signalWaiters();
189                 throw ie;
190             }
191         }
192
193
194         public void release() {
195             Signaller s = endRead();
196             if (s != null) s.signalWaiters();
197         }
198
199
200         synchronized void signalWaiters() {
201             ReaderLock.this.notifyAll();
202         }
203
204         public boolean attempt(long msecs) throws InterruptedException {
205             if (Thread.interrupted()) throw new InterruptedException ();
206             InterruptedException ie = null;
207             synchronized (this) {
208                 if (msecs <= 0)
209                     return startRead();
210                 else if (startReadFromNewReader())
211                     return true;
212                 else {
213                     long waitTime = msecs;
214                     long start = System.currentTimeMillis();
215                     for (; ;) {
216                         try {
217                             ReaderLock.this.wait(waitTime);
218                         } catch (InterruptedException ex) {
219                             cancelledWaitingReader();
220                             ie = ex;
221                             break;
222                         }
223                         if (startReadFromWaitingReader())
224                             return true;
225                         else {
226                             waitTime = msecs - (System.currentTimeMillis() - start);
227                             if (waitTime <= 0) {
228                                 cancelledWaitingReader();
229                                 break;
230                             }
231                         }
232                     }
233                 }
234             }
235             // safeguard on interrupt or timeout:
236 writerLock_.signalWaiters();
237             if (ie != null)
238                 throw ie;
239             else
240                 return false; // timed out
241 }
242
243     }
244
245     protected class WriterLock extends Signaller implements Sync {
246
247         public void acquire() throws InterruptedException {
248             if (Thread.interrupted()) throw new InterruptedException ();
249             InterruptedException ie = null;
250             synchronized (this) {
251                 if (!startWriteFromNewWriter()) {
252                     for (; ;) {
253                         try {
254                             WriterLock.this.wait();
255                             if (startWriteFromWaitingWriter())
256                                 return;
257                         } catch (InterruptedException ex) {
258                             cancelledWaitingWriter();
259                             WriterLock.this.notify();
260                             ie = ex;
261                             break;
262                         }
263                     }
264                 }
265             }
266             if (ie != null) {
267                 // Fall through outside synch on interrupt.
268 // On exception, we may need to signal readers.
269 // It is not worth checking here whether it is strictly necessary.
270 readerLock_.signalWaiters();
271                 throw ie;
272             }
273         }
274
275         public void release() {
276             Signaller s = endWrite();
277             if (s != null) s.signalWaiters();
278         }
279
280         synchronized void signalWaiters() {
281             WriterLock.this.notify();
282         }
283
284         public boolean attempt(long msecs) throws InterruptedException {
285             if (Thread.interrupted()) throw new InterruptedException ();
286             InterruptedException ie = null;
287             synchronized (this) {
288                 if (msecs <= 0)
289                     return startWrite();
290                 else if (startWriteFromNewWriter())
291                     return true;
292                 else {
293                     long waitTime = msecs;
294                     long start = System.currentTimeMillis();
295                     for (; ;) {
296                         try {
297                             WriterLock.this.wait(waitTime);
298                         } catch (InterruptedException ex) {
299                             cancelledWaitingWriter();
300                             WriterLock.this.notify();
301                             ie = ex;
302                             break;
303                         }
304                         if (startWriteFromWaitingWriter())
305                             return true;
306                         else {
307                             waitTime = msecs - (System.currentTimeMillis() - start);
308                             if (waitTime <= 0) {
309                                 cancelledWaitingWriter();
310                                 WriterLock.this.notify();
311                                 break;
312                             }
313                         }
314                     }
315                 }
316             }
317
318             readerLock_.signalWaiters();
319             if (ie != null)
320                 throw ie;
321             else
322                 return false; // timed out
323 }
324
325     }
326
327
328 }
329
330

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags