--- jsr166/src/test/tck/ReentrantReadWriteLockTest.java 2011/05/02 00:03:34 1.46 +++ jsr166/src/test/tck/ReentrantReadWriteLockTest.java 2011/05/03 06:08:49 1.56 @@ -7,6 +7,7 @@ */ 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; @@ -32,7 +33,6 @@ public class ReentrantReadWriteLockTest } } - /** * A runnable calling lockInterruptibly that expects to be * interrupted @@ -59,12 +59,56 @@ public class ReentrantReadWriteLockTest } /** - * Releases lock, checking that it had a hold count of 1. + * 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 releaseLock(ReentrantReadWriteLock.WriteLock lock) { - assertTrue(lock.isHeldByCurrentThread()); - lock.unlock(); - assertFalse(lock.isHeldByCurrentThread()); + 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(); } /** @@ -110,7 +154,6 @@ public class ReentrantReadWriteLockTest assertEquals(0, rl.getReadLockCount()); } - /** * locking an unlocked fair lock succeeds */ @@ -181,11 +224,10 @@ public class ReentrantReadWriteLockTest } } - /** * write-unlocking an unlocked lock throws IllegalMonitorStateException */ - public void testUnlock_IllegalMonitorStateException() { + public void testWriteUnlock_IllegalMonitorStateException() { ReentrantReadWriteLock rl = new ReentrantReadWriteLock(); try { rl.writeLock().unlock(); @@ -193,6 +235,16 @@ public class ReentrantReadWriteLockTest } 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 @@ -205,10 +257,10 @@ public class ReentrantReadWriteLockTest lock.writeLock().lockInterruptibly(); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - t.join(); - releaseLock(lock.writeLock()); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -219,13 +271,13 @@ public class ReentrantReadWriteLockTest lock.writeLock().lock(); Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { - lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS); + lock.writeLock().tryLock(LONG_DELAY_MS, MILLISECONDS); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - lock.writeLock().unlock(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -239,11 +291,10 @@ public class ReentrantReadWriteLockTest lock.readLock().lockInterruptibly(); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - lock.writeLock().unlock(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -257,12 +308,12 @@ public class ReentrantReadWriteLockTest lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - t.join(); + awaitTermination(t); + releaseWriteLock(lock); } - /** * write-tryLock fails if locked */ @@ -274,8 +325,8 @@ public class ReentrantReadWriteLockTest assertFalse(lock.writeLock().tryLock()); }}); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -289,8 +340,8 @@ public class ReentrantReadWriteLockTest assertFalse(lock.readLock().tryLock()); }}); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -305,12 +356,12 @@ public class ReentrantReadWriteLockTest lock.readLock().unlock(); }}); - 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(); @@ -326,16 +377,15 @@ public class ReentrantReadWriteLockTest lock.writeLock().unlock(); }}); - Thread.sleep(SHORT_DELAY_MS); + awaitTermination(t1); + waitForQueuedThread(lock, t2); + assertNotWriteLocked(lock); lock.readLock().unlock(); - t1.join(MEDIUM_DELAY_MS); - t2.join(MEDIUM_DELAY_MS); - assertTrue(!t1.isAlive()); - assertTrue(!t2.isAlive()); + awaitTermination(t2); } /** - * 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(); @@ -351,12 +401,11 @@ public class ReentrantReadWriteLockTest lock.readLock().unlock(); }}); - 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); } /** @@ -377,6 +426,9 @@ public class ReentrantReadWriteLockTest public void testReadHoldingWriteLock2() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread t1 = newStartedThread(new CheckedRunnable() { public void realRun() { lock.readLock().lock(); @@ -388,16 +440,14 @@ public class ReentrantReadWriteLockTest lock.readLock().unlock(); }}); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - 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); } /** @@ -407,6 +457,9 @@ public class ReentrantReadWriteLockTest public void testReadHoldingWriteLock3() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread t1 = newStartedThread(new CheckedRunnable() { public void realRun() { lock.writeLock().lock(); @@ -418,19 +471,16 @@ public class ReentrantReadWriteLockTest lock.writeLock().unlock(); }}); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - 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 * other threads are waiting for writelock @@ -438,6 +488,9 @@ public class ReentrantReadWriteLockTest public void testWriteHoldingWriteLock4() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); lock.writeLock().lock(); + lock.writeLock().lock(); + lock.writeLock().unlock(); + Thread t1 = newStartedThread(new CheckedRunnable() { public void realRun() { lock.writeLock().lock(); @@ -449,19 +502,19 @@ public class ReentrantReadWriteLockTest 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(); - Thread.sleep(SHORT_DELAY_MS); - 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); } - /** * Fair Read trylock succeeds if write locked by current thread */ @@ -480,6 +533,9 @@ public class ReentrantReadWriteLockTest public void testReadHoldingWriteLockFair2() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); lock.writeLock().lock(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread t1 = newStartedThread(new CheckedRunnable() { public void realRun() { lock.readLock().lock(); @@ -491,19 +547,16 @@ public class ReentrantReadWriteLockTest lock.readLock().unlock(); }}); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - 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 @@ -511,6 +564,9 @@ public class ReentrantReadWriteLockTest public void testReadHoldingWriteLockFair3() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); lock.writeLock().lock(); + lock.readLock().lock(); + lock.readLock().unlock(); + Thread t1 = newStartedThread(new CheckedRunnable() { public void realRun() { lock.writeLock().lock(); @@ -522,19 +578,16 @@ public class ReentrantReadWriteLockTest lock.writeLock().unlock(); }}); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); + assertTrue(lock.isWriteLockedByCurrentThread()); lock.readLock().lock(); lock.readLock().unlock(); - Thread.sleep(SHORT_DELAY_MS); - 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 @@ -553,7 +606,8 @@ public class ReentrantReadWriteLockTest lock.writeLock().unlock(); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t1); + waitForQueuedThread(lock, t2); assertTrue(lock.isWriteLockedByCurrentThread()); assertEquals(1, lock.getWriteHoldCount()); lock.writeLock().lock(); @@ -561,14 +615,11 @@ public class ReentrantReadWriteLockTest 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 */ @@ -581,7 +632,7 @@ public class ReentrantReadWriteLockTest lock.readLock().unlock(); }}); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } @@ -596,11 +647,10 @@ public class ReentrantReadWriteLockTest assertFalse(lock.writeLock().tryLock()); }}); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - /** * Fair Read tryLock succeeds if readlocked but not writelocked */ @@ -613,12 +663,10 @@ public class ReentrantReadWriteLockTest lock.readLock().unlock(); }}); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - - /** * Fair write tryLock fails when readlocked */ @@ -630,12 +678,10 @@ public class ReentrantReadWriteLockTest assertFalse(lock.writeLock().tryLock()); }}); - t.join(); + awaitTermination(t); lock.readLock().unlock(); } - - /** * write timed tryLock times out if locked */ @@ -647,7 +693,7 @@ public class ReentrantReadWriteLockTest assertFalse(lock.writeLock().tryLock(1, MILLISECONDS)); }}); - t.join(); + awaitTermination(t); assertTrue(lock.writeLock().isHeldByCurrentThread()); lock.writeLock().unlock(); } @@ -663,12 +709,11 @@ public class ReentrantReadWriteLockTest assertFalse(lock.readLock().tryLock(1, MILLISECONDS)); }}); - t.join(); + awaitTermination(t); assertTrue(lock.writeLock().isHeldByCurrentThread()); lock.writeLock().unlock(); } - /** * write lockInterruptibly succeeds if lock free else is interruptible */ @@ -680,11 +725,10 @@ public class ReentrantReadWriteLockTest lock.writeLock().lockInterruptibly(); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - Thread.sleep(SHORT_DELAY_MS); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -698,10 +742,10 @@ public class ReentrantReadWriteLockTest lock.readLock().lockInterruptibly(); }}); - Thread.sleep(SHORT_DELAY_MS); + waitForQueuedThread(lock, t); t.interrupt(); - t.join(); - lock.writeLock().unlock(); + awaitTermination(t); + releaseWriteLock(lock); } /** @@ -714,6 +758,18 @@ public class ReentrantReadWriteLockTest 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) {} } /** @@ -729,19 +785,33 @@ 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 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 */ @@ -749,7 +819,10 @@ public class ReentrantReadWriteLockTest final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); lock.writeLock().lock(); - assertFalse(c.await(SHORT_DELAY_MS, MILLISECONDS)); + long startTime = System.nanoTime(); + long timeoutMillis = 10; + assertFalse(c.await(timeoutMillis, MILLISECONDS)); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis); lock.writeLock().unlock(); } @@ -771,46 +844,21 @@ public class ReentrantReadWriteLockTest public void testAwait() throws InterruptedException { final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); final Condition c = lock.writeLock().newCondition(); + 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(); }}); - 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); } /** @@ -819,114 +867,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(); + 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()); + } }}); - 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(); + final CountDownLatch locked = new CountDownLatch(1); Thread t = newStartedThread(new CheckedInterruptedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); - 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()); + } }}); - 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(); + 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()); + } }}); - 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(); + 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 = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { - lock.writeLock().lock(); + writeLock.lock(); + locked.countDown(); c.await(); - lock.writeLock().unlock(); + writeLock.unlock(); }}); - 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); } /** @@ -958,20 +1095,19 @@ public class ReentrantReadWriteLockTest 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(); } /** @@ -989,33 +1125,31 @@ 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 */ @@ -1025,20 +1159,19 @@ public class ReentrantReadWriteLockTest 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(); } /** @@ -1050,23 +1183,25 @@ public class ReentrantReadWriteLockTest 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(); } /** @@ -1091,7 +1226,6 @@ public class ReentrantReadWriteLockTest } catch (NullPointerException success) {} } - /** * getWaitingThreads throws NPE if null */ @@ -1128,7 +1262,6 @@ public class ReentrantReadWriteLockTest } catch (IllegalMonitorStateException success) {} } - /** * getWaitQueueLength throws IAE if not owned */ @@ -1154,7 +1287,6 @@ public class ReentrantReadWriteLockTest } catch (IllegalMonitorStateException success) {} } - /** * getWaitingThreads throws IAE if not owned */ @@ -1180,78 +1312,74 @@ 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(); + final CountDownLatch locked = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); assertFalse(lock.hasWaiters(c)); + locked.countDown(); assertEquals(0, lock.getWaitQueueLength(c)); c.await(); lock.writeLock().unlock(); }}); - 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(); + final CountDownLatch locked = new CountDownLatch(1); Thread t = newStartedThread(new CheckedRunnable() { public void realRun() throws InterruptedException { lock.writeLock().lock(); - assertFalse(lock.hasWaiters(c)); assertEquals(0, lock.getWaitQueueLength(c)); + locked.countDown(); c.await(); lock.writeLock().unlock(); }}); - 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 Condition c = lock.writeLock().newCondition(); + 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(); assertTrue(lock.getWaitingThreads(c).isEmpty()); + locked1.countDown(); c.await(); lock.writeLock().unlock(); }}); @@ -1260,6 +1388,7 @@ public class ReentrantReadWriteLockTest public void realRun() throws InterruptedException { lock.writeLock().lock(); assertFalse(lock.getWaitingThreads(c).isEmpty()); + locked2.countDown(); c.await(); lock.writeLock().unlock(); }}); @@ -1267,25 +1396,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); } /**