X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=support%2Fgeneral%2Fsrc%2Ftest%2Fjava%2Forg%2Fwamblee%2Fconcurrency%2FReadWriteLockTest.java;h=2e7996244752d68de4d659e1fa270821e79615d2;hb=ddd261f331280640c5b53c7128230b629ebcd268;hp=2c159e9437639c4c563b12d0b0010003ffedfe81;hpb=32a62ca2c752e33a7873ac868a7a1f289caedcd4;p=utils diff --git a/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java b/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java index 2c159e94..2e799624 100644 --- a/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java +++ b/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.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 junit.framework.Assert; @@ -27,20 +27,22 @@ import junit.framework.TestCase; */ public class ReadWriteLockTest extends TestCase { /** - * + * */ private static final int HALF_SECOND = 500; + /** - * + * */ private static final int ONE_SECOND = 1000; + /** - * + * */ private static final int TWO_SECONDS = 2000; - private ReadWriteLock _lock; - private int _nReaders; - private int _nWriters; + private ReadWriteLock lock; + private int nReaders; + private int nWriters; /** * Constructor for ReadWriteLockTest. @@ -52,27 +54,27 @@ public class ReadWriteLockTest extends TestCase { } private synchronized int getReaderCount() { - return _nReaders; + return nReaders; } private synchronized int getWriterCount() { - return _nWriters; + return nWriters; } synchronized void incrementReaderCount() { - _nReaders++; + nReaders++; } synchronized void incrementWriterCount() { - _nWriters++; + nWriters++; } synchronized void decrementReaderCount() { - _nReaders--; + nReaders--; } synchronized void decrementWriterCount() { - _nWriters--; + nWriters--; } /* @@ -80,14 +82,14 @@ public class ReadWriteLockTest extends TestCase { */ protected void setUp() throws Exception { super.setUp(); - _lock = new ReadWriteLock(); + lock = new ReadWriteLock(); } /* * @see TestCase#tearDown() */ protected void tearDown() throws Exception { - _lock = null; + lock = null; super.tearDown(); } @@ -95,16 +97,16 @@ public class ReadWriteLockTest extends TestCase { * Acquire and release a read lock. */ public void testRead() { - _lock.acquireRead(); - _lock.releaseRead(); + lock.acquireRead(); + lock.releaseRead(); } /** * Acquire and release a write lock. */ public void testWrite() { - _lock.acquireWrite(); - _lock.releaseWrite(); + lock.acquireWrite(); + lock.releaseWrite(); } /** @@ -113,9 +115,9 @@ public class ReadWriteLockTest extends TestCase { * @throws InterruptedException May not occur. */ public void testMultipleReaders() throws InterruptedException { - Runnable runnable = new ReadLocker(_lock, this, TWO_SECONDS); + Runnable runnable = new ReadLocker(lock, this, TWO_SECONDS); - Thread t1 = new Thread(runnable); + Thread t1 = new Thread(runnable); t1.start(); Thread t2 = new Thread(runnable); @@ -132,9 +134,9 @@ public class ReadWriteLockTest extends TestCase { * @throws InterruptedException May not occur. */ public void testSingleWriter() throws InterruptedException { - WriteLocker writer = new WriteLocker(_lock, this, ONE_SECOND); - Thread t1 = new Thread(writer); - Thread t2 = new Thread(writer); + WriteLocker writer = new WriteLocker(lock, this, ONE_SECOND); + Thread t1 = new Thread(writer); + Thread t2 = new Thread(writer); t1.start(); t2.start(); @@ -151,10 +153,11 @@ public class ReadWriteLockTest extends TestCase { * @throws InterruptedException May not occur. */ public void testMultipleWriters() throws InterruptedException { - WriteLocker writer1 = new WriteLocker(_lock, this, HALF_SECOND + ONE_SECOND); - WriteLocker writer2 = new WriteLocker(_lock, this, ONE_SECOND); - Thread t1 = new Thread(writer1); - Thread t2 = new Thread(writer2); + WriteLocker writer1 = new WriteLocker(lock, this, + HALF_SECOND + ONE_SECOND); + WriteLocker writer2 = new WriteLocker(lock, this, ONE_SECOND); + Thread t1 = new Thread(writer1); + Thread t2 = new Thread(writer2); t1.start(); Thread.sleep(HALF_SECOND); @@ -180,10 +183,10 @@ public class ReadWriteLockTest extends TestCase { * @throws InterruptedException May not occur. */ public void testReadWrite1() throws InterruptedException { - ReadLocker readLocker = new ReadLocker(_lock, this, TWO_SECONDS); - Thread t1 = new Thread(readLocker); - WriteLocker writeLocker = new WriteLocker(_lock, this, TWO_SECONDS); - Thread t2 = new Thread(writeLocker); + ReadLocker readLocker = new ReadLocker(lock, this, TWO_SECONDS); + Thread t1 = new Thread(readLocker); + WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS); + Thread t2 = new Thread(writeLocker); t1.start(); // acquire read lock Thread.sleep(HALF_SECOND); @@ -213,20 +216,24 @@ public class ReadWriteLockTest extends TestCase { * @throws InterruptedException May not occur. */ public void testReadWrite2() throws InterruptedException { - ReadLocker readLocker1 = new ReadLocker(_lock, this, TWO_SECONDS + HALF_SECOND); - ReadLocker readLocker2 = new ReadLocker(_lock, this, TWO_SECONDS + HALF_SECOND); - Thread t1 = new Thread(readLocker1); - Thread t2 = new Thread(readLocker2); - WriteLocker writeLocker = new WriteLocker(_lock, this, TWO_SECONDS); - Thread t3 = new Thread(writeLocker); - - t1.start(); // acquire read lock + ReadLocker readLocker1 = new ReadLocker(lock, this, + TWO_SECONDS + HALF_SECOND); + ReadLocker readLocker2 = new ReadLocker(lock, this, + TWO_SECONDS + HALF_SECOND); + Thread t1 = new Thread(readLocker1); + Thread t2 = new Thread(readLocker2); + WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS); + Thread t3 = new Thread(writeLocker); + + t1.start(); // acquire read lock [0, 2.5] Thread.sleep(ONE_SECOND); + // t = 1 assertTrue(getReaderCount() == 1); - t2.start(); + t2.start(); // acquire read lock [1, 3.5] Thread.sleep(HALF_SECOND); + // t = 1.5 assertTrue(getReaderCount() == 2); - t3.start(); + t3.start(); // write lock Thread.sleep(HALF_SECOND); // 2 seconds, @@ -238,7 +245,7 @@ public class ReadWriteLockTest extends TestCase { // have been released. assertTrue(getReaderCount() == 1); assertTrue(getWriterCount() == 0); - Thread.sleep(HALF_SECOND); + Thread.sleep(ONE_SECOND); // 4 seconds underway, write lock must have // been acquired. @@ -257,10 +264,10 @@ public class ReadWriteLockTest extends TestCase { * @throws InterruptedException May not occur. */ public void testReadWrite3() throws InterruptedException { - ReadLocker readLocker = new ReadLocker(_lock, this, TWO_SECONDS); - Thread t1 = new Thread(readLocker); - WriteLocker writeLocker = new WriteLocker(_lock, this, TWO_SECONDS); - Thread t2 = new Thread(writeLocker); + ReadLocker readLocker = new ReadLocker(lock, this, TWO_SECONDS); + Thread t1 = new Thread(readLocker); + WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS); + Thread t2 = new Thread(writeLocker); t2.start(); // acquire write lock Thread.sleep(HALF_SECOND); @@ -304,12 +311,12 @@ public class ReadWriteLockTest extends TestCase { try { t1 = new Thread(new Runnable() { public void run() { - ReadWriteLockTest.this._lock.acquireRead(); + ReadWriteLockTest.this.lock.acquireRead(); } }); t1.start(); Thread.sleep(ONE_SECOND); // wait until thread is started - _lock.releaseRead(); // release lock from wrong thread. + lock.releaseRead(); // release lock from wrong thread. } catch (RuntimeException e) { return; // ok } finally { @@ -331,12 +338,12 @@ public class ReadWriteLockTest extends TestCase { try { t1 = new Thread(new Runnable() { public void run() { - ReadWriteLockTest.this._lock.acquireWrite(); + ReadWriteLockTest.this.lock.acquireWrite(); } }); t1.start(); Thread.sleep(ONE_SECOND); // wait until thread is started - _lock.releaseWrite(); // release lock from wrong thread. + lock.releaseWrite(); // release lock from wrong thread. } catch (RuntimeException e) { return; // ok } finally { @@ -352,8 +359,8 @@ public class ReadWriteLockTest extends TestCase { */ public void testAcquireReadTwice() { try { - _lock.acquireRead(); - _lock.acquireRead(); + lock.acquireRead(); + lock.acquireRead(); } catch (RuntimeException e) { // ok return; @@ -368,8 +375,8 @@ public class ReadWriteLockTest extends TestCase { */ public void testAcquireWriteTwice() { try { - _lock.acquireWrite(); - _lock.acquireWrite(); + lock.acquireWrite(); + lock.acquireWrite(); } catch (RuntimeException e) { return; // ok } @@ -383,8 +390,8 @@ public class ReadWriteLockTest extends TestCase { */ public void testAcquireReadFollowedByWrite() { try { - _lock.acquireRead(); - _lock.acquireWrite(); + lock.acquireRead(); + lock.acquireWrite(); } catch (RuntimeException e) { return; // ok } @@ -398,8 +405,8 @@ public class ReadWriteLockTest extends TestCase { */ public void testAcquireWriteFollowedByRead() { try { - _lock.acquireWrite(); - _lock.acquireRead(); + lock.acquireWrite(); + lock.acquireRead(); } catch (RuntimeException e) { return; // ok } @@ -413,8 +420,8 @@ public class ReadWriteLockTest extends TestCase { */ public void testAcquireReadFollowedByReleaseaWrite() { try { - _lock.acquireRead(); - _lock.releaseWrite(); + lock.acquireRead(); + lock.releaseWrite(); } catch (RuntimeException e) { return; // ok } @@ -428,8 +435,8 @@ public class ReadWriteLockTest extends TestCase { */ public void testAcquireWriteFollowedByReleaseRead() { try { - _lock.acquireWrite(); - _lock.releaseRead(); + lock.acquireWrite(); + lock.releaseRead(); } catch (RuntimeException e) { return; // ok } @@ -445,30 +452,30 @@ public class ReadWriteLockTest extends TestCase { * lock, and performs a callback after the lock has been released. */ class ReadLocker implements Runnable { - private ReadWriteLock _lock; - private ReadWriteLockTest _lockTest; - private int _sleepTime; + private ReadWriteLock lock; + private ReadWriteLockTest lockTest; + private int sleepTime; public ReadLocker(ReadWriteLock aLock, ReadWriteLockTest aLockTest, int aSleepTime) { - _lock = aLock; - _lockTest = aLockTest; - _sleepTime = aSleepTime; + lock = aLock; + lockTest = aLockTest; + sleepTime = aSleepTime; } public void run() { - _lock.acquireRead(); - _lockTest.incrementReaderCount(); + lock.acquireRead(); + lockTest.incrementReaderCount(); try { - Thread.sleep(_sleepTime); + Thread.sleep(sleepTime); } catch (InterruptedException e) { - Assert.fail("ReadLocker thread was interrupted." - + Thread.currentThread()); + Assert.fail("ReadLocker thread was interrupted." + + Thread.currentThread()); } - _lock.releaseRead(); - _lockTest.decrementReaderCount(); + lock.releaseRead(); + lockTest.decrementReaderCount(); } } @@ -479,29 +486,29 @@ class ReadLocker implements Runnable { * lock, and performs a callback after the lock has been released. */ class WriteLocker implements Runnable { - private ReadWriteLock _lock; - private ReadWriteLockTest _lockTest; - private int _sleepTime; + private ReadWriteLock lock; + private ReadWriteLockTest lockTest; + private int sleepTime; public WriteLocker(ReadWriteLock aLock, ReadWriteLockTest aLockTest, int aSleepTime) { - _lock = aLock; - _lockTest = aLockTest; - _sleepTime = aSleepTime; + lock = aLock; + lockTest = aLockTest; + sleepTime = aSleepTime; } public void run() { - _lock.acquireWrite(); - _lockTest.incrementWriterCount(); + lock.acquireWrite(); + lockTest.incrementWriterCount(); try { - Thread.sleep(_sleepTime); + Thread.sleep(sleepTime); } catch (InterruptedException e) { - Assert.fail("WriteLocker thread was interrupted: " - + Thread.currentThread()); + Assert.fail("WriteLocker thread was interrupted: " + + Thread.currentThread()); } - _lock.releaseWrite(); - _lockTest.decrementWriterCount(); + lock.releaseWrite(); + lockTest.decrementWriterCount(); } }