001: /* ========================================================================
002: * JCommon : a free general purpose class library for the Java(tm) platform
003: * ========================================================================
004: *
005: * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
006: *
007: * Project Info: http://www.jfree.org/jcommon/index.html
008: *
009: * This library is free software; you can redistribute it and/or modify it
010: * under the terms of the GNU Lesser General Public License as published by
011: * the Free Software Foundation; either version 2.1 of the License, or
012: * (at your option) any later version.
013: *
014: * This library is distributed in the hope that it will be useful, but
015: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017: * License for more details.
018: *
019: * You should have received a copy of the GNU Lesser General Public
020: * License along with this library; if not, write to the Free Software
021: * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022: * USA.
023: *
024: * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025: * in the United States and other countries.]
026: *
027: * ---------------------
028: * ReaderWriterLock.java
029: * ---------------------
030: *
031: * $Id: ReaderWriterLock.java,v 1.3 2005/10/18 13:18:34 mungady Exp $
032: *
033: * Changes
034: * -------
035: * 29-Jan-2003 : Added standard header (DG);
036: *
037: */
038:
039: package org.jfree.threads;
040:
041: import java.util.ArrayList;
042: import java.util.Iterator;
043:
044: /**
045: * A reader-writer lock from "Java Threads" by Scott Oak and Henry Wong.
046: *
047: * @author Scott Oak and Henry Wong
048: */
049: public class ReaderWriterLock {
050:
051: /**
052: * A node for the waiting list.
053: *
054: * @author Scott Oak and Henry Wong
055: */
056: private static class ReaderWriterNode {
057:
058: /** A reader. */
059: protected static final int READER = 0;
060:
061: /** A writer. */
062: protected static final int WRITER = 1;
063:
064: /** The thread. */
065: protected Thread t;
066:
067: /** The state. */
068: protected int state;
069:
070: /** The number of acquires.*/
071: protected int nAcquires;
072:
073: /**
074: * Creates a new node.
075: *
076: * @param t the thread.
077: * @param state the state.
078: */
079: private ReaderWriterNode(final Thread t, final int state) {
080: this .t = t;
081: this .state = state;
082: this .nAcquires = 0;
083: }
084:
085: }
086:
087: /** The waiting threads. */
088: private ArrayList waiters;
089:
090: /**
091: * Default constructor.
092: */
093: public ReaderWriterLock() {
094: this .waiters = new ArrayList();
095: }
096:
097: /**
098: * Grab the read lock.
099: */
100: public synchronized void lockRead() {
101: final ReaderWriterNode node;
102: final Thread me = Thread.currentThread();
103: final int index = getIndex(me);
104: if (index == -1) {
105: node = new ReaderWriterNode(me, ReaderWriterNode.READER);
106: this .waiters.add(node);
107: } else {
108: node = (ReaderWriterNode) this .waiters.get(index);
109: }
110: while (getIndex(me) > firstWriter()) {
111: try {
112: wait();
113: } catch (Exception e) {
114: System.err
115: .println("ReaderWriterLock.lockRead(): exception.");
116: System.err.print(e.getMessage());
117: }
118: }
119: node.nAcquires++;
120: }
121:
122: /**
123: * Grab the write lock.
124: */
125: public synchronized void lockWrite() {
126: final ReaderWriterNode node;
127: final Thread me = Thread.currentThread();
128: final int index = getIndex(me);
129: if (index == -1) {
130: node = new ReaderWriterNode(me, ReaderWriterNode.WRITER);
131: this .waiters.add(node);
132: } else {
133: node = (ReaderWriterNode) this .waiters.get(index);
134: if (node.state == ReaderWriterNode.READER) {
135: throw new IllegalArgumentException("Upgrade lock");
136: }
137: node.state = ReaderWriterNode.WRITER;
138: }
139: while (getIndex(me) != 0) {
140: try {
141: wait();
142: } catch (Exception e) {
143: System.err
144: .println("ReaderWriterLock.lockWrite(): exception.");
145: System.err.print(e.getMessage());
146: }
147: }
148: node.nAcquires++;
149: }
150:
151: /**
152: * Unlock.
153: */
154: public synchronized void unlock() {
155:
156: final ReaderWriterNode node;
157: final Thread me = Thread.currentThread();
158: final int index = getIndex(me);
159: if (index > firstWriter()) {
160: throw new IllegalArgumentException("Lock not held");
161: }
162: node = (ReaderWriterNode) this .waiters.get(index);
163: node.nAcquires--;
164: if (node.nAcquires == 0) {
165: this .waiters.remove(index);
166: }
167: notifyAll();
168: }
169:
170: /**
171: * Returns the index of the first waiting writer.
172: *
173: * @return The index.
174: */
175: private int firstWriter() {
176: final Iterator e = this .waiters.iterator();
177: int index = 0;
178: while (e.hasNext()) {
179: final ReaderWriterNode node = (ReaderWriterNode) e.next();
180: if (node.state == ReaderWriterNode.WRITER) {
181: return index;
182: }
183: index += 1;
184: }
185: return Integer.MAX_VALUE;
186: }
187:
188: /**
189: * Returns the index of a thread.
190: *
191: * @param t the thread.
192: *
193: * @return The index.
194: */
195: private int getIndex(final Thread t) {
196: final Iterator e = this .waiters.iterator();
197: int index = 0;
198: while (e.hasNext()) {
199: final ReaderWriterNode node = (ReaderWriterNode) e.next();
200: if (node.t == t) {
201: return index;
202: }
203: index += 1;
204: }
205: return -1;
206: }
207:
208: }
|