--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java 2009/11/17 14:45:32 1.34 +++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java 2011/05/07 11:15:04 1.57 @@ -1,23 +1,25 @@ /* * Written by Doug Lea with assistance from members of JCP JSR-166 * Expert Group and released to the public domain, as explained at - * http://creativecommons.org/licenses/publicdomain + * http://creativecommons.org/publicdomain/zero/1.0/ * Other contributors include Andrew Wright, Jeffrey Hayes, * Pat Fisher, Mike Judd. */ import junit.framework.*; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.locks.*; import java.util.concurrent.*; +import static java.util.concurrent.TimeUnit.MILLISECONDS; import java.io.*; import java.util.*; public class ReentrantReadWriteLockTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run (suite()); + junit.textui.TestRunner.run(suite()); } public static Test suite() { - return new TestSuite(ReentrantReadWriteLockTest.class); + return new TestSuite(ReentrantReadWriteLockTest.class); } /** @@ -31,7 +33,6 @@ public class ReentrantReadWriteLockTest } } - /** * A runnable calling lockInterruptibly that expects to be * interrupted @@ -58,18 +59,71 @@ public class ReentrantReadWriteLockTest } /** + * Releases write lock, checking that it had a hold count of 1. + */ + void releaseWriteLock(ReentrantReadWriteLock lock) { + ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock(); + assertTrue(writeLock.isHeldByCurrentThread()); + writeLock.unlock(); + assertFalse(writeLock.isHeldByCurrentThread()); + } + + /** + * Spin-waits until lock.hasQueuedThread(t) becomes true. + */ + void waitForQueuedThread(ReentrantReadWriteLock lock, Thread t) { + long startTime = System.nanoTime(); + while (!lock.hasQueuedThread(t)) { + if (millisElapsedSince(startTime) > LONG_DELAY_MS) + throw new AssertionError("timed out"); + Thread.yield(); + } + } + + /** + * Checks that lock is not write-locked. + */ + void assertNotWriteLocked(ReentrantReadWriteLock lock) { + assertFalse(lock.isWriteLocked()); + assertFalse(lock.isWriteLockedByCurrentThread()); + assertEquals(0, lock.getWriteHoldCount()); + } + + /** + * Checks that condition c has no waiters. + */ + void assertHasNoWaiters(PublicReentrantReadWriteLock lock, Condition c) { + assertHasWaiters(lock, c, new Thread[] {}); + } + + /** + * Checks that condition c has exactly the given waiter threads. + */ + void assertHasWaiters(PublicReentrantReadWriteLock lock, Condition c, + Thread... threads) { + lock.writeLock().lock(); + assertEquals(threads.length > 0, lock.hasWaiters(c)); + assertEquals(threads.length, lock.getWaitQueueLength(c)); + assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty()); + assertEquals(threads.length, lock.getWaitingThreads(c).size()); + assertEquals(new HashSet(lock.getWaitingThreads(c)), + new HashSet(Arrays.asList(threads))); + lock.writeLock().unlock(); + } + + /** * Constructor sets given fairness, and is in unlocked state */ public void testConstructor() { - ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); + ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); assertFalse(rl.isFair()); assertFalse(rl.isWriteLocked()); assertEquals(0, rl.getReadLockCount()); - ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true); + ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true); assertTrue(r2.isFair()); assertFalse(r2.isWriteLocked()); assertEquals(0, r2.getReadLockCount()); - ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false); + ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false); assertFalse(r3.isFair()); assertFalse(r3.isWriteLocked()); assertEquals(0, r3.getReadLockCount()); @@ -79,7 +133,7 @@ public class ReentrantReadWriteLockTest * write-locking and read-locking an unlocked lock succeed */ public void testLock() { - ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); + ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); rl.writeLock().lock(); assertTrue(rl.isWriteLocked()); assertTrue(rl.isWriteLockedByCurrentThread()); @@ -100,12 +154,11 @@ public class ReentrantReadWriteLockTest assertEquals(0, rl.getReadLockCount()); } - /** * locking an unlocked fair lock succeeds */ public void testFairLock() { - ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true); + ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true); rl.writeLock().lock(); assertTrue(rl.isWriteLocked()); assertTrue(rl.isWriteLockedByCurrentThread()); @@ -130,251 +183,236 @@ public class ReentrantReadWriteLockTest * getWriteHoldCount returns number of recursive holds */ public void testGetWriteHoldCount() { - ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - for (int i = 1; i <= SIZE; i++) { - lock.writeLock().lock(); - assertEquals(i,lock.getWriteHoldCount()); - } - for (int i = SIZE; i > 0; i--) { - lock.writeLock().unlock(); - assertEquals(i-1,lock.getWriteHoldCount()); - } + ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + for (int i = 1; i <= SIZE; i++) { + lock.writeLock().lock(); + assertEquals(i,lock.getWriteHoldCount()); + } + for (int i = SIZE; i > 0; i--) { + lock.writeLock().unlock(); + assertEquals(i-1,lock.getWriteHoldCount()); + } } /** * WriteLock.getHoldCount returns number of recursive holds */ public void testGetHoldCount() { - ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - for (int i = 1; i <= SIZE; i++) { - lock.writeLock().lock(); - assertEquals(i,lock.writeLock().getHoldCount()); - } - for (int i = SIZE; i > 0; i--) { - lock.writeLock().unlock(); - assertEquals(i-1,lock.writeLock().getHoldCount()); - } + ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + for (int i = 1; i <= SIZE; i++) { + lock.writeLock().lock(); + assertEquals(i,lock.writeLock().getHoldCount()); + } + for (int i = SIZE; i > 0; i--) { + lock.writeLock().unlock(); + assertEquals(i-1,lock.writeLock().getHoldCount()); + } } /** * getReadHoldCount returns number of recursive holds */ public void testGetReadHoldCount() { - ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - for (int i = 1; i <= SIZE; i++) { - lock.readLock().lock(); - assertEquals(i,lock.getReadHoldCount()); - } - for (int i = SIZE; i > 0; i--) { - lock.readLock().unlock(); - assertEquals(i-1,lock.getReadHoldCount()); - } + ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + for (int i = 1; i <= SIZE; i++) { + lock.readLock().lock(); + assertEquals(i,lock.getReadHoldCount()); + } + for (int i = SIZE; i > 0; i--) { + lock.readLock().unlock(); + assertEquals(i-1,lock.getReadHoldCount()); + } } - /** * write-unlocking an unlocked lock throws IllegalMonitorStateException */ - public void testUnlock_IllegalMonitorStateException() { - ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); - try { - rl.writeLock().unlock(); - shouldThrow(); - } catch (IllegalMonitorStateException success) {} + public void testWriteUnlock_IllegalMonitorStateException() { + ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); + try { + rl.writeLock().unlock(); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} } + /** + * read-unlocking an unlocked lock throws IllegalMonitorStateException + */ + public void testReadUnlock_IllegalMonitorStateException() { + ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); + try { + rl.readLock().unlock(); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } /** * write-lockInterruptibly is interruptible */ public void testWriteLockInterruptibly_Interrupted() throws Exception { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lockInterruptibly(); - lock.writeLock().unlock(); - lock.writeLock().lockInterruptibly(); - lock.writeLock().unlock(); }}); - lock.writeLock().lock(); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } /** * timed write-tryLock is interruptible */ public void testWriteTryLock_Interrupted() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { - lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS); + lock.writeLock().tryLock(LONG_DELAY_MS, MILLISECONDS); }}); - t.start(); + waitForQueuedThread(lock, t); t.interrupt(); - lock.writeLock().unlock(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } /** * read-lockInterruptibly is interruptible */ public void testReadLockInterruptibly_Interrupted() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.readLock().lockInterruptibly(); }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } /** * timed read-tryLock is interruptible */ public void testReadTryLock_Interrupted() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { - lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS); + lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS); }}); - t.start(); + waitForQueuedThread(lock, t); t.interrupt(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } - /** * write-tryLock fails if locked */ public void testWriteTryLockWhenLocked() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.writeLock().tryLock()); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertFalse(lock.writeLock().tryLock()); + }}); - t.start(); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** * read-tryLock fails if locked */ public void testReadTryLockWhenLocked() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.readLock().tryLock()); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertFalse(lock.readLock().tryLock()); + }}); - t.start(); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** * Multiple threads can hold a read lock when not write-locked */ public void testMultipleReadLocks() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertTrue(lock.readLock().tryLock()); - lock.readLock().unlock(); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.readLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertTrue(lock.readLock().tryLock()); + lock.readLock().unlock(); + }}); - t.start(); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } /** - * A writelock succeeds after reading threads unlock + * A writelock succeeds only after reading threads unlock */ public void testWriteAfterMultipleReadLocks() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.readLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.readLock().lock(); + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + delay(SHORT_DELAY_MS); lock.readLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + awaitTermination(t1); + awaitTermination(t2); + assertNotWriteLocked(lock); } /** - * Readlocks succeed after a writing thread unlocks + * Readlocks succeed only after a writing thread unlocks */ public void testReadAfterWriteLock() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } /** * Read trylock succeeds if write locked by current thread */ public void testReadHoldingWriteLock() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); assertTrue(lock.readLock().tryLock()); lock.readLock().unlock(); lock.writeLock().unlock(); @@ -385,111 +423,103 @@ public class ReentrantReadWriteLockTest * other threads are waiting for readlock */ public void testReadHoldingWriteLock2() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - - t1.start(); - t2.start(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } /** - * Read lock succeeds if write locked by current thread even if + * Read lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ public void testReadHoldingWriteLock3() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - t1.start(); - t2.start(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } - /** - * Write lock succeeds if write locked by current thread even if + * Write lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ public void testWriteHoldingWriteLock4() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - t1.start(); - t2.start(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); lock.writeLock().lock(); lock.writeLock().unlock(); + + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertEquals(1, lock.getWriteHoldCount()); + lock.writeLock().lock(); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertEquals(2, lock.getWriteHoldCount()); lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } - /** * Fair Read trylock succeeds if write locked by current thread */ public void testReadHoldingWriteLockFair() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); assertTrue(lock.readLock().tryLock()); lock.readLock().unlock(); lock.writeLock().unlock(); @@ -500,199 +530,169 @@ public class ReentrantReadWriteLockTest * other threads are waiting for readlock */ public void testReadHoldingWriteLockFair2() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.readLock().lock(); - lock.readLock().unlock(); - } - }); - - t1.start(); - t2.start(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.readLock().lock(); + lock.readLock().unlock(); + }}); + + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } - /** * Fair Read lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ public void testReadHoldingWriteLockFair3() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - - t1.start(); - t2.start(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } - /** * Fair Write lock succeeds if write locked by current thread even if * other threads are waiting for writelock */ public void testWriteHoldingWriteLockFair4() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.writeLock().lock(); - Thread t1 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); - Thread t2 = new Thread(new Runnable() { - public void run() { - lock.writeLock().lock(); - lock.writeLock().unlock(); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.writeLock().lock(); + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + lock.writeLock().unlock(); + }}); - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); assertTrue(lock.isWriteLockedByCurrentThread()); - assertTrue(lock.getWriteHoldCount() == 1); + assertEquals(1, lock.getWriteHoldCount()); lock.writeLock().lock(); - assertTrue(lock.getWriteHoldCount() == 2); + assertEquals(2, lock.getWriteHoldCount()); lock.writeLock().unlock(); lock.writeLock().lock(); lock.writeLock().unlock(); - lock.writeLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + releaseWriteLock(lock); + awaitTermination(t1); + awaitTermination(t2); } - /** * Read tryLock succeeds if readlocked but not writelocked */ public void testTryLockWhenReadLocked() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertTrue(lock.readLock().tryLock()); - lock.readLock().unlock(); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.readLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertTrue(lock.readLock().tryLock()); + lock.readLock().unlock(); + }}); - t.start(); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - - /** * write tryLock fails when readlocked */ public void testWriteTryLockWhenReadLocked() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.writeLock().tryLock()); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.readLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertFalse(lock.writeLock().tryLock()); + }}); - t.start(); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - /** * Fair Read tryLock succeeds if readlocked but not writelocked */ public void testTryLockWhenReadLockedFair() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertTrue(lock.readLock().tryLock()); - lock.readLock().unlock(); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.readLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertTrue(lock.readLock().tryLock()); + lock.readLock().unlock(); + }}); - t.start(); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - - /** * Fair write tryLock fails when readlocked */ public void testWriteTryLockWhenReadLockedFair() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); - lock.readLock().lock(); - Thread t = new Thread(new Runnable() { - public void run() { - threadAssertFalse(lock.writeLock().tryLock()); - } - }); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); + lock.readLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + assertFalse(lock.writeLock().tryLock()); + }}); - t.start(); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - - /** * write timed tryLock times out if locked */ public void testWriteTryLock_Timeout() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new CheckedRunnable() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS)); + assertFalse(lock.writeLock().tryLock(1, MILLISECONDS)); }}); - t.start(); - t.join(); + awaitTermination(t); assertTrue(lock.writeLock().isHeldByCurrentThread()); lock.writeLock().unlock(); } @@ -701,74 +701,81 @@ public class ReentrantReadWriteLockTest * read timed tryLock times out if write-locked */ public void testReadTryLock_Timeout() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - lock.writeLock().lock(); - Thread t = new Thread(new CheckedRunnable() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + lock.writeLock().lock(); + Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS)); + assertFalse(lock.readLock().tryLock(1, MILLISECONDS)); }}); - t.start(); - t.join(); + awaitTermination(t); assertTrue(lock.writeLock().isHeldByCurrentThread()); lock.writeLock().unlock(); } - /** * write lockInterruptibly succeeds if lock free else is interruptible */ public void testWriteLockInterruptibly() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lockInterruptibly(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lockInterruptibly(); }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** - * read lockInterruptibly succeeds if lock free else is interruptible + * read lockInterruptibly succeeds if lock free else is interruptible */ public void testReadLockInterruptibly() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lockInterruptibly(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.readLock().lockInterruptibly(); }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** * Calling await without holding lock throws IllegalMonitorStateException */ public void testAwait_IllegalMonitor() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); try { c.await(); shouldThrow(); } catch (IllegalMonitorStateException success) {} + try { + c.await(LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + try { + c.awaitNanos(100); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + try { + c.awaitUninterruptibly(); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} } /** * Calling signal without holding lock throws IllegalMonitorStateException */ public void testSignal_IllegalMonitor() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); try { c.signal(); @@ -777,27 +784,44 @@ public class ReentrantReadWriteLockTest } /** + * Calling signalAll without holding lock throws IllegalMonitorStateException + */ + public void testSignalAll_IllegalMonitor() { + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final Condition c = lock.writeLock().newCondition(); + try { + c.signalAll(); + shouldThrow(); + } catch (IllegalMonitorStateException success) {} + } + + /** * awaitNanos without a signal times out */ public void testAwaitNanos_Timeout() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - lock.writeLock().lock(); - long t = c.awaitNanos(100); - assertTrue(t <= 0); + long startTime = System.nanoTime(); + long timeoutMillis = 10; + long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis); + long nanosRemaining = c.awaitNanos(timeoutNanos); + assertTrue(nanosRemaining <= 0); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis); lock.writeLock().unlock(); } - /** - * timed await without a signal times out + * timed await without a signal times out */ public void testAwait_Timeout() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); lock.writeLock().lock(); - assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)); + long startTime = System.nanoTime(); + long timeoutMillis = 10; + assertFalse(c.await(timeoutMillis, MILLISECONDS)); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis); lock.writeLock().unlock(); } @@ -805,7 +829,7 @@ public class ReentrantReadWriteLockTest * awaitUntil without a signal times out */ public void testAwaitUntil_Timeout() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); lock.writeLock().lock(); java.util.Date d = new java.util.Date(); @@ -817,49 +841,23 @@ public class ReentrantReadWriteLockTest * await returns when signalled */ public void testAwait() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new CheckedRunnable() { + final CountDownLatch locked = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); + locked.countDown(); c.await(); lock.writeLock().unlock(); }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + locked.await(); lock.writeLock().lock(); c.signal(); + assertTrue(t.isAlive()); lock.writeLock().unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); - } - - /** A helper class for uninterruptible wait tests */ - class UninterruptableThread extends Thread { - private Lock lock; - private Condition c; - - public volatile boolean canAwake = false; - public volatile boolean interrupted = false; - public volatile boolean lockStarted = false; - - public UninterruptableThread(Lock lock, Condition c) { - this.lock = lock; - this.c = c; - } - - public synchronized void run() { - lock.lock(); - lockStarted = true; - - while (!canAwake) { - c.awaitUninterruptibly(); - } - - interrupted = isInterrupted(); - lock.unlock(); - } + awaitTermination(t); } /** @@ -868,119 +866,203 @@ public class ReentrantReadWriteLockTest public void testAwaitUninterruptibly() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c); - - thread.start(); - - while (!thread.lockStarted) { - Thread.sleep(100); - } + final CountDownLatch locked = new CountDownLatch(1); + final AtomicBoolean canAwake = new AtomicBoolean(false); + Thread t = newStartedThread(new CheckedRunnable() { + public void realRun() { + lock.writeLock().lock(); + locked.countDown(); + c.awaitUninterruptibly(); + assertTrue(Thread.interrupted()); + lock.writeLock().unlock(); + }}); + locked.await(); lock.writeLock().lock(); - try { - thread.interrupt(); - thread.canAwake = true; - c.signal(); - } finally { - lock.writeLock().unlock(); - } - - thread.join(); - assertTrue(thread.interrupted); - assertFalse(thread.isAlive()); + lock.writeLock().unlock(); + t.interrupt(); + t.join(10); + assertTrue(t.isAlive()); + lock.writeLock().lock(); + c.signal(); + lock.writeLock().unlock(); + awaitTermination(t); } /** * await is interruptible */ public void testAwait_Interrupt() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final CountDownLatch locked = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - c.await(); - lock.writeLock().unlock(); + assertTrue(lock.isWriteLocked()); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertHasNoWaiters(lock, c); + locked.countDown(); + try { + c.await(); + } finally { + assertTrue(lock.isWriteLocked()); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertHasNoWaiters(lock, c); + lock.writeLock().unlock(); + assertFalse(Thread.interrupted()); + } }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + locked.await(); + assertHasWaiters(lock, c, t); t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); + awaitTermination(t); + assertFalse(lock.isWriteLocked()); } /** * awaitNanos is interruptible */ public void testAwaitNanos_Interrupt() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final CountDownLatch locked = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000); - lock.writeLock().unlock(); + assertTrue(lock.isWriteLocked()); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertHasNoWaiters(lock, c); + locked.countDown(); + try { + c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); + } finally { + assertTrue(lock.isWriteLocked()); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertHasNoWaiters(lock, c); + lock.writeLock().unlock(); + assertFalse(Thread.interrupted()); + } }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + locked.await(); + assertHasWaiters(lock, c, t); t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); + awaitTermination(t); + assertFalse(lock.isWriteLocked()); } /** * awaitUntil is interruptible */ public void testAwaitUntil_Interrupt() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new CheckedInterruptedRunnable() { + final CountDownLatch locked = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); + assertTrue(lock.isWriteLocked()); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertHasNoWaiters(lock, c); + locked.countDown(); java.util.Date d = new java.util.Date(); - c.awaitUntil(new java.util.Date(d.getTime() + 10000)); - lock.writeLock().unlock(); + try { + c.awaitUntil(new java.util.Date(d.getTime() + 10000)); + } finally { + assertTrue(lock.isWriteLocked()); + assertTrue(lock.isWriteLockedByCurrentThread()); + assertHasNoWaiters(lock, c); + lock.writeLock().unlock(); + assertFalse(Thread.interrupted()); + } }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + locked.await(); + assertHasWaiters(lock, c, t); t.interrupt(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); + awaitTermination(t); + assertFalse(lock.isWriteLocked()); } /** * signalAll wakes up all threads */ public void testSignalAll() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t1 = new Thread(new CheckedRunnable() { + final CountDownLatch locked = new CountDownLatch(2); + final Lock writeLock = lock.writeLock(); + Thread t1 = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - lock.writeLock().lock(); + writeLock.lock(); + locked.countDown(); c.await(); - lock.writeLock().unlock(); + writeLock.unlock(); }}); - Thread t2 = new Thread(new CheckedRunnable() { + Thread t2 = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - lock.writeLock().lock(); + writeLock.lock(); + locked.countDown(); c.await(); - lock.writeLock().unlock(); + writeLock.unlock(); }}); - t1.start(); - t2.start(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); + locked.await(); + writeLock.lock(); + assertHasWaiters(lock, c, t1, t2); c.signalAll(); - lock.writeLock().unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); + assertHasNoWaiters(lock, c); + writeLock.unlock(); + awaitTermination(t1); + awaitTermination(t2); + } + + /** + * signal wakes up waiting threads in FIFO order. + */ + public void testSignalWakesFifo() throws InterruptedException { + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); + final Condition c = lock.writeLock().newCondition(); + final CountDownLatch locked1 = new CountDownLatch(1); + final CountDownLatch locked2 = new CountDownLatch(1); + final Lock writeLock = lock.writeLock(); + Thread t1 = newStartedThread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + writeLock.lock(); + locked1.countDown(); + c.await(); + writeLock.unlock(); + }}); + + locked1.await(); + + Thread t2 = newStartedThread(new CheckedRunnable() { + public void realRun() throws InterruptedException { + writeLock.lock(); + locked2.countDown(); + c.await(); + writeLock.unlock(); + }}); + + locked2.await(); + + writeLock.lock(); + assertHasWaiters(lock, c, t1, t2); + assertFalse(lock.hasQueuedThreads()); + c.signal(); + assertHasWaiters(lock, c, t2); + assertTrue(lock.hasQueuedThread(t1)); + assertFalse(lock.hasQueuedThread(t2)); + c.signal(); + assertHasNoWaiters(lock, c); + assertTrue(lock.hasQueuedThread(t1)); + assertTrue(lock.hasQueuedThread(t2)); + writeLock.unlock(); + awaitTermination(t1); + awaitTermination(t2); } /** @@ -1007,32 +1089,31 @@ public class ReentrantReadWriteLockTest * hasQueuedThreads reports whether there are waiting threads */ public void testhasQueuedThreads() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); assertFalse(lock.hasQueuedThreads()); lock.writeLock().lock(); + assertFalse(lock.hasQueuedThreads()); + long startTime = System.nanoTime(); t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(lock.hasQueuedThreads()); + waitForQueuedThread(lock, t1); t2.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t2); assertTrue(lock.hasQueuedThreads()); t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t1); assertTrue(lock.hasQueuedThreads()); lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t2); assertFalse(lock.hasQueuedThreads()); - t1.join(); - t2.join(); } /** * hasQueuedThread(null) throws NPE */ public void testHasQueuedThreadNPE() { - final ReentrantReadWriteLock sync = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock sync = new ReentrantReadWriteLock(); try { sync.hasQueuedThread(null); shouldThrow(); @@ -1043,91 +1124,90 @@ public class ReentrantReadWriteLockTest * hasQueuedThread reports whether a thread is queued. */ public void testHasQueuedThread() throws InterruptedException { - final ReentrantReadWriteLock sync = new ReentrantReadWriteLock(); - Thread t1 = new Thread(new InterruptedLockRunnable(sync)); - Thread t2 = new Thread(new InterruptibleLockRunnable(sync)); - assertFalse(sync.hasQueuedThread(t1)); - assertFalse(sync.hasQueuedThread(t2)); - sync.writeLock().lock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + Thread t1 = new Thread(new InterruptedLockRunnable(lock)); + Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); + assertFalse(lock.hasQueuedThread(t1)); + assertFalse(lock.hasQueuedThread(t2)); + lock.writeLock().lock(); + long startTime = System.nanoTime(); t1.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThread(t1)); + waitForQueuedThread(lock, t1); + assertTrue(lock.hasQueuedThread(t1)); + assertFalse(lock.hasQueuedThread(t2)); t2.start(); - Thread.sleep(SHORT_DELAY_MS); - assertTrue(sync.hasQueuedThread(t1)); - assertTrue(sync.hasQueuedThread(t2)); + waitForQueuedThread(lock, t2); + assertTrue(lock.hasQueuedThread(t1)); + assertTrue(lock.hasQueuedThread(t2)); t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t1)); - assertTrue(sync.hasQueuedThread(t2)); - sync.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t1)); - Thread.sleep(SHORT_DELAY_MS); - assertFalse(sync.hasQueuedThread(t2)); - t1.join(); - t2.join(); + awaitTermination(t1); + assertFalse(lock.hasQueuedThread(t1)); + assertTrue(lock.hasQueuedThread(t2)); + lock.writeLock().unlock(); + awaitTermination(t2); + assertFalse(lock.hasQueuedThread(t1)); + assertFalse(lock.hasQueuedThread(t2)); } - /** * getQueueLength reports number of waiting threads */ public void testGetQueueLength() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); assertEquals(0, lock.getQueueLength()); lock.writeLock().lock(); + long startTime = System.nanoTime(); t1.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t1); assertEquals(1, lock.getQueueLength()); t2.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t2); assertEquals(2, lock.getQueueLength()); t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t1); assertEquals(1, lock.getQueueLength()); lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t2); assertEquals(0, lock.getQueueLength()); - t1.join(); - t2.join(); } /** * getQueuedThreads includes waiting threads */ public void testGetQueuedThreads() throws InterruptedException { - final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); Thread t1 = new Thread(new InterruptedLockRunnable(lock)); Thread t2 = new Thread(new InterruptibleLockRunnable(lock)); assertTrue(lock.getQueuedThreads().isEmpty()); lock.writeLock().lock(); + long startTime = System.nanoTime(); assertTrue(lock.getQueuedThreads().isEmpty()); t1.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t1); + assertEquals(1, lock.getQueuedThreads().size()); assertTrue(lock.getQueuedThreads().contains(t1)); t2.start(); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t2); + assertEquals(2, lock.getQueuedThreads().size()); assertTrue(lock.getQueuedThreads().contains(t1)); assertTrue(lock.getQueuedThreads().contains(t2)); t1.interrupt(); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t1); assertFalse(lock.getQueuedThreads().contains(t1)); assertTrue(lock.getQueuedThreads().contains(t2)); + assertEquals(1, lock.getQueuedThreads().size()); lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t2); assertTrue(lock.getQueuedThreads().isEmpty()); - t1.join(); - t2.join(); } /** * hasWaiters throws NPE if null */ public void testHasWaitersNPE() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); try { lock.hasWaiters(null); shouldThrow(); @@ -1138,19 +1218,18 @@ public class ReentrantReadWriteLockTest * getWaitQueueLength throws NPE if null */ public void testGetWaitQueueLengthNPE() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); try { lock.getWaitQueueLength(null); shouldThrow(); } catch (NullPointerException success) {} } - /** * getWaitingThreads throws NPE if null */ public void testGetWaitingThreadsNPE() { - final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); try { lock.getWaitingThreads(null); shouldThrow(); @@ -1161,9 +1240,9 @@ public class ReentrantReadWriteLockTest * hasWaiters throws IAE if not owned */ public void testHasWaitersIAE() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); try { lock2.hasWaiters(c); shouldThrow(); @@ -1174,7 +1253,7 @@ public class ReentrantReadWriteLockTest * hasWaiters throws IMSE if not locked */ public void testHasWaitersIMSE() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); try { lock.hasWaiters(c); @@ -1182,14 +1261,13 @@ public class ReentrantReadWriteLockTest } catch (IllegalMonitorStateException success) {} } - /** * getWaitQueueLength throws IAE if not owned */ public void testGetWaitQueueLengthIAE() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(); try { lock2.getWaitQueueLength(c); shouldThrow(); @@ -1200,7 +1278,7 @@ public class ReentrantReadWriteLockTest * getWaitQueueLength throws IMSE if not locked */ public void testGetWaitQueueLengthIMSE() { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); try { lock.getWaitQueueLength(c); @@ -1208,14 +1286,13 @@ public class ReentrantReadWriteLockTest } catch (IllegalMonitorStateException success) {} } - /** * getWaitingThreads throws IAE if not owned */ public void testGetWaitingThreadsIAE() { - final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock(); try { lock2.getWaitingThreads(c); shouldThrow(); @@ -1226,7 +1303,7 @@ public class ReentrantReadWriteLockTest * getWaitingThreads throws IMSE if not locked */ public void testGetWaitingThreadsIMSE() { - final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); try { lock.getWaitingThreads(c); @@ -1234,88 +1311,83 @@ public class ReentrantReadWriteLockTest } catch (IllegalMonitorStateException success) {} } - /** * hasWaiters returns true when a thread is waiting, else false */ public void testHasWaiters() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new CheckedRunnable() { + final CountDownLatch locked = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - threadAssertFalse(lock.hasWaiters(c)); - threadAssertEquals(0, lock.getWaitQueueLength(c)); + assertFalse(lock.hasWaiters(c)); + locked.countDown(); + assertEquals(0, lock.getWaitQueueLength(c)); c.await(); lock.writeLock().unlock(); }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + locked.await(); lock.writeLock().lock(); assertTrue(lock.hasWaiters(c)); assertEquals(1, lock.getWaitQueueLength(c)); c.signal(); + assertHasNoWaiters(lock, c); lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); - assertEquals(0, lock.getWaitQueueLength(c)); - lock.writeLock().unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); + awaitTermination(t); + assertHasNoWaiters(lock, c); } /** * getWaitQueueLength returns number of waiting threads */ public void testGetWaitQueueLength() throws InterruptedException { - final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t = new Thread(new CheckedRunnable() { + final CountDownLatch locked = new CountDownLatch(1); + Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - threadAssertFalse(lock.hasWaiters(c)); - threadAssertEquals(0, lock.getWaitQueueLength(c)); + assertEquals(0, lock.getWaitQueueLength(c)); + locked.countDown(); c.await(); lock.writeLock().unlock(); }}); - t.start(); - Thread.sleep(SHORT_DELAY_MS); + locked.await(); lock.writeLock().lock(); - assertTrue(lock.hasWaiters(c)); + assertHasWaiters(lock, c, t); assertEquals(1, lock.getWaitQueueLength(c)); c.signal(); - lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); + assertHasNoWaiters(lock, c); assertEquals(0, lock.getWaitQueueLength(c)); lock.writeLock().unlock(); - t.join(SHORT_DELAY_MS); - assertFalse(t.isAlive()); + awaitTermination(t); } - /** * getWaitingThreads returns only and all waiting threads */ public void testGetWaitingThreads() throws InterruptedException { - final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); + final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); - Thread t1 = new Thread(new CheckedRunnable() { + final CountDownLatch locked1 = new CountDownLatch(1); + final CountDownLatch locked2 = new CountDownLatch(1); + Thread t1 = new Thread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - threadAssertTrue(lock.getWaitingThreads(c).isEmpty()); + assertTrue(lock.getWaitingThreads(c).isEmpty()); + locked1.countDown(); c.await(); lock.writeLock().unlock(); }}); - Thread t2 = new Thread(new CheckedRunnable() { + Thread t2 = new Thread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - threadAssertFalse(lock.getWaitingThreads(c).isEmpty()); + assertFalse(lock.getWaitingThreads(c).isEmpty()); + locked2.countDown(); c.await(); lock.writeLock().unlock(); }}); @@ -1323,25 +1395,25 @@ public class ReentrantReadWriteLockTest lock.writeLock().lock(); assertTrue(lock.getWaitingThreads(c).isEmpty()); lock.writeLock().unlock(); + t1.start(); - Thread.sleep(SHORT_DELAY_MS); + locked1.await(); t2.start(); - Thread.sleep(SHORT_DELAY_MS); + locked2.await(); + lock.writeLock().lock(); assertTrue(lock.hasWaiters(c)); assertTrue(lock.getWaitingThreads(c).contains(t1)); assertTrue(lock.getWaitingThreads(c).contains(t2)); + assertEquals(2, lock.getWaitingThreads(c).size()); c.signalAll(); + assertHasNoWaiters(lock, c); lock.writeLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); - assertTrue(lock.getWaitingThreads(c).isEmpty()); - lock.writeLock().unlock(); - t1.join(SHORT_DELAY_MS); - t2.join(SHORT_DELAY_MS); - assertFalse(t1.isAlive()); - assertFalse(t2.isAlive()); + + awaitTermination(t1); + awaitTermination(t2); + + assertHasNoWaiters(lock, c); } /**