source code formatting.

[utils] / support / general / src / main / java / org / wamblee / concurrency / ReadWriteLock.java

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 e765816133ed87d4dce3c39daa247fa8cf7250de..678801d50140f13373f3dfe88980365812c458ef 100644 (file)
--- a/support/general/src/main/java/org/wamblee/concurrency/ReadWriteLock.java
+++ b/support/general/src/main/java/org/wamblee/concurrency/ReadWriteLock.java
@@ -1,18 +1,18 @@
 /*
  * Copyright 2005 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.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ 
+ */
 package org.wamblee.concurrency;
 
 import java.util.HashSet;
@@ -31,20 +31,20 @@ public class ReadWriteLock {
      * already been  acquired before it is release. This check adds robustness
      * to the application.
      */
-    private HashSet<Thread> _readers;
+    private HashSet<Thread> readers;
 
     /**
      * The thread that has acquired the lock for writing or null if no such
      * thread exists currently.
      */
-    private Thread _writer;
+    private Thread writer;
 
     /**
      * Constructs read-write lock.
      */
     public ReadWriteLock() {
-        _readers     = new HashSet<Thread>();
-        _writer      = null;
+        readers = new HashSet<Thread>();
+        writer = null;
     }
 
     /**
@@ -55,19 +55,19 @@ public class ReadWriteLock {
      *         already acquired.
      */
     public synchronized void acquireRead() {
-        if (_readers.contains(Thread.currentThread())) {
+        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()) {
+        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) {
+        while (writer != null) {
             try {
                 wait();
             } catch (InterruptedException e) {
@@ -75,7 +75,7 @@ public class ReadWriteLock {
             }
         }
 
-        _readers.add(Thread.currentThread());
+        readers.add(Thread.currentThread());
     }
 
     /**
@@ -86,12 +86,12 @@ public class ReadWriteLock {
      *         this thread.
      */
     public synchronized void releaseRead() {
-        if (!_readers.remove(Thread.currentThread())) {
+        if (!readers.remove(Thread.currentThread())) {
             throw new IllegalStateException(
                 "Cannot release read lock because current thread has not acquired it.");
         }
 
-        if (_readers.size() == 0) {
+        if (readers.size() == 0) {
             notifyAll();
         }
     }
@@ -104,21 +104,21 @@ public class ReadWriteLock {
      *         already acquired.
      */
     public synchronized void acquireWrite() {
-        if (_writer == Thread.currentThread()) {
+        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())) {
+        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 
-        while ((_writer != null) || (_readers.size() > 0)) {
+        while ((writer != null) || (readers.size() > 0)) {
             try {
                 wait();
             } catch (InterruptedException e) {
@@ -126,7 +126,7 @@ public class ReadWriteLock {
             }
         }
 
-        _writer = Thread.currentThread();
+        writer = Thread.currentThread();
 
         // notification not necessary since all writers and
         // readers are now blocked by this thread.
@@ -138,12 +138,12 @@ public class ReadWriteLock {
      * @throws IllegalStateException Thrown when the lock was not acquired.
      */
     public synchronized void releaseWrite() {
-        if (_writer != Thread.currentThread()) {
+        if (writer != Thread.currentThread()) {
             throw new IllegalStateException(
                 "Cannot release write lock because it was not acquired. ");
         }
 
-        _writer = null;
+        writer = null;
         notifyAll();
     }
 }