*
*/
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.
}
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--;
}
/*
*/
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();
}
* 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();
}
/**
* @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);
t1.start();
* @throws InterruptedException May not occur.
*/
public void testSingleWriter() throws InterruptedException {
- WriteLocker writer = new WriteLocker(_lock, this, ONE_SECOND);
+ WriteLocker writer = new WriteLocker(lock, this, ONE_SECOND);
Thread t1 = new Thread(writer);
Thread t2 = new Thread(writer);
* @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);
+ 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);
* @throws InterruptedException May not occur.
*/
public void testReadWrite1() throws InterruptedException {
- ReadLocker readLocker = new ReadLocker(_lock, this, TWO_SECONDS);
+ ReadLocker readLocker = new ReadLocker(lock, this, TWO_SECONDS);
Thread t1 = new Thread(readLocker);
- WriteLocker writeLocker = new WriteLocker(_lock, this, TWO_SECONDS);
+ WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS);
Thread t2 = new Thread(writeLocker);
t1.start(); // acquire read lock
* @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);
+ 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);
+ WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS);
Thread t3 = new Thread(writeLocker);
t1.start(); // acquire read lock [0, 2.5]
* @throws InterruptedException May not occur.
*/
public void testReadWrite3() throws InterruptedException {
- ReadLocker readLocker = new ReadLocker(_lock, this, TWO_SECONDS);
+ ReadLocker readLocker = new ReadLocker(lock, this, TWO_SECONDS);
Thread t1 = new Thread(readLocker);
- WriteLocker writeLocker = new WriteLocker(_lock, this, TWO_SECONDS);
+ WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS);
Thread t2 = new Thread(writeLocker);
t2.start(); // acquire write lock
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 {
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 {
*/
public void testAcquireReadTwice() {
try {
- _lock.acquireRead();
- _lock.acquireRead();
+ lock.acquireRead();
+ lock.acquireRead();
} catch (RuntimeException e) {
// ok
return;
*/
public void testAcquireWriteTwice() {
try {
- _lock.acquireWrite();
- _lock.acquireWrite();
+ lock.acquireWrite();
+ lock.acquireWrite();
} catch (RuntimeException e) {
return; // ok
}
*/
public void testAcquireReadFollowedByWrite() {
try {
- _lock.acquireRead();
- _lock.acquireWrite();
+ lock.acquireRead();
+ lock.acquireWrite();
} catch (RuntimeException e) {
return; // ok
}
*/
public void testAcquireWriteFollowedByRead() {
try {
- _lock.acquireWrite();
- _lock.acquireRead();
+ lock.acquireWrite();
+ lock.acquireRead();
} catch (RuntimeException e) {
return; // ok
}
*/
public void testAcquireReadFollowedByReleaseaWrite() {
try {
- _lock.acquireRead();
- _lock.releaseWrite();
+ lock.acquireRead();
+ lock.releaseWrite();
} catch (RuntimeException e) {
return; // ok
}
*/
public void testAcquireWriteFollowedByReleaseRead() {
try {
- _lock.acquireWrite();
- _lock.releaseRead();
+ lock.acquireWrite();
+ lock.releaseRead();
} catch (RuntimeException e) {
return; // ok
}
* 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());
}
- _lock.releaseRead();
- _lockTest.decrementReaderCount();
+ lock.releaseRead();
+ lockTest.decrementReaderCount();
}
}
* 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());
}
- _lock.releaseWrite();
- _lockTest.decrementWriterCount();
+ lock.releaseWrite();
+ lockTest.decrementWriterCount();
}
}
git://wamblee.org / utils / blobdiff