X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=support%2Fgeneral%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fconcurrency%2FReadWriteLock.java;h=59f876c94d3e293d1e290c9b380b0e968c5649fa;hb=17775e14ecfb286e59f67117e5cee7e21e95ab1f;hp=bfa4d311a02862162ef6fd5640313a1893daf876;hpb=0d8d8f24656e585ee75558cfd6a4c661f8f14985;p=utils

diff --git a/support/general/src/main/java/org/wamblee/concurrency/ReadWriteLock.java b/support/general/src/main/java/org/wamblee/concurrency/ReadWriteLock.java
index bfa4d311..59f876c9 100644
--- a/support/general/src/main/java/org/wamblee/concurrency/ReadWriteLock.java
+++ b/support/general/src/main/java/org/wamblee/concurrency/ReadWriteLock.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2005 the original author or authors.
+ * Copyright 2005-2010 the original author or authors.
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,6 @@ package org.wamblee.concurrency;
 
 import java.util.HashSet;
 
-
 /**
  * Read-write lock for allowing multiple concurrent readers or at most one
  * writer. This implementation does not aim for high performance but for
@@ -26,10 +25,10 @@ import java.util.HashSet;
  */
 public class ReadWriteLock {
     /**
-     * Sets containing the references to the threads that are currently
-     * reading. This administration is useful to check that the lock has
-     * already been  acquired before it is release. This check adds robustness
-     * to the application.
+     * Sets containing the references to the threads that are currently reading.
+     * This administration is useful to check that the lock has already been
+     * acquired before it is release. This check adds robustness to the
+     * application.
      */
     private HashSet<Thread> readers;
 
@@ -43,28 +42,28 @@ public class ReadWriteLock {
      * Constructs read-write lock.
      */
     public ReadWriteLock() {
-        readers     = new HashSet<Thread>();
-        writer      = null;
+        readers = new HashSet<Thread>();
+        writer = null;
     }
 
     /**
-     * Acquires the lock for reading. This call will block until the lock can
-     * be acquired.
-     *
-     * @throws IllegalStateException Thrown if the read or  write lock is
-     *         already acquired.
+     * Acquires the lock for reading. This call will block until the lock can be
+     * acquired.
+     * 
+     * @throws IllegalStateException
+     *             Thrown if the read or write lock is already acquired.
      */
     public synchronized void acquireRead() {
         if (readers.contains(Thread.currentThread())) {
             throw new IllegalStateException(
-                "Read lock already acquired by current thread: "
-                + Thread.currentThread());
+                "Read lock already acquired by current thread: " +
+                    Thread.currentThread());
         }
 
         if (writer == Thread.currentThread()) {
             throw new IllegalStateException(
-                "Trying to acquire the read lock while already holding a write lock: "
-                + Thread.currentThread());
+                "Trying to acquire the read lock while already holding a write lock: " +
+                    Thread.currentThread());
         }
 
         while (writer != null) {
@@ -79,11 +78,11 @@ public class ReadWriteLock {
     }
 
     /**
-     * Releases the lock for reading. Note: This implementation assumes that
-     * the lock has already been acquired for reading previously.
-     *
-     * @throws IllegalStateException Thrown when the lock was not acquired by
-     *         this thread.
+     * Releases the lock for reading. Note: This implementation assumes that the
+     * lock has already been acquired for reading previously.
+     * 
+     * @throws IllegalStateException
+     *             Thrown when the lock was not acquired by this thread.
      */
     public synchronized void releaseRead() {
         if (!readers.remove(Thread.currentThread())) {
@@ -99,25 +98,25 @@ public class ReadWriteLock {
     /**
      * Acquires the lock for writing. This call will block until the lock has
      * been acquired.
-     *
-     * @throws IllegalStateException Thrown if the read or write lock is
-     *         already acquired.
+     * 
+     * @throws IllegalStateException
+     *             Thrown if the read or write lock is already acquired.
      */
     public synchronized void acquireWrite() {
         if (writer == Thread.currentThread()) {
             throw new IllegalStateException(
-                "Trying to acquire a write lock while already holding the write lock: "
-                + Thread.currentThread());
+                "Trying to acquire a write lock while already holding the write lock: " +
+                    Thread.currentThread());
         }
 
         if (readers.contains(Thread.currentThread())) {
             throw new IllegalStateException(
-                "Trying to acquire a write lock while already holding the read lock: "
-                + Thread.currentThread());
+                "Trying to acquire a write lock while already holding the read lock: " +
+                    Thread.currentThread());
         }
 
         // wait until there are no more writers and no more
-        // readers 
+        // readers
         while ((writer != null) || (readers.size() > 0)) {
             try {
                 wait();
@@ -134,8 +133,9 @@ public class ReadWriteLock {
 
     /**
      * Releases the lock for writing.
-     *
-     * @throws IllegalStateException Thrown when the lock was not acquired.
+     * 
+     * @throws IllegalStateException
+     *             Thrown when the lock was not acquired.
      */
     public synchronized void releaseWrite() {
         if (writer != Thread.currentThread()) {