ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.34 by jsr166, Tue Nov 17 14:45:32 2009 UTC vs.
Revision 1.56 by jsr166, Tue May 3 06:08:49 2011 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
10 + import java.util.concurrent.atomic.AtomicBoolean;
11   import java.util.concurrent.locks.*;
12   import java.util.concurrent.*;
13 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
14   import java.io.*;
15   import java.util.*;
16  
17   public class ReentrantReadWriteLockTest extends JSR166TestCase {
18      public static void main(String[] args) {
19 <        junit.textui.TestRunner.run (suite());
19 >        junit.textui.TestRunner.run(suite());
20      }
21      public static Test suite() {
22 <        return new TestSuite(ReentrantReadWriteLockTest.class);
22 >        return new TestSuite(ReentrantReadWriteLockTest.class);
23      }
24  
25      /**
# Line 31 | Line 33 | public class ReentrantReadWriteLockTest
33          }
34      }
35  
34
36      /**
37       * A runnable calling lockInterruptibly that expects to be
38       * interrupted
# Line 58 | Line 59 | public class ReentrantReadWriteLockTest
59      }
60  
61      /**
62 +     * Releases write lock, checking that it had a hold count of 1.
63 +     */
64 +    void releaseWriteLock(ReentrantReadWriteLock lock) {
65 +        ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
66 +        assertTrue(writeLock.isHeldByCurrentThread());
67 +        writeLock.unlock();
68 +        assertFalse(writeLock.isHeldByCurrentThread());
69 +    }
70 +
71 +    /**
72 +     * Spin-waits until lock.hasQueuedThread(t) becomes true.
73 +     */
74 +    void waitForQueuedThread(ReentrantReadWriteLock lock, Thread t) {
75 +        long startTime = System.nanoTime();
76 +        while (!lock.hasQueuedThread(t)) {
77 +            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
78 +                throw new AssertionError("timed out");
79 +            Thread.yield();
80 +        }
81 +    }
82 +
83 +    /**
84 +     * Checks that lock is not write-locked.
85 +     */
86 +    void assertNotWriteLocked(ReentrantReadWriteLock lock) {
87 +        assertFalse(lock.isWriteLocked());
88 +        assertFalse(lock.isWriteLockedByCurrentThread());
89 +        assertEquals(0, lock.getWriteHoldCount());
90 +    }
91 +
92 +    /**
93 +     * Checks that condition c has no waiters.
94 +     */
95 +    void assertHasNoWaiters(PublicReentrantReadWriteLock lock, Condition c) {
96 +        assertHasWaiters(lock, c, new Thread[] {});
97 +    }
98 +
99 +    /**
100 +     * Checks that condition c has exactly the given waiter threads.
101 +     */
102 +    void assertHasWaiters(PublicReentrantReadWriteLock lock, Condition c,
103 +                          Thread... threads) {
104 +        lock.writeLock().lock();
105 +        assertEquals(threads.length > 0, lock.hasWaiters(c));
106 +        assertEquals(threads.length, lock.getWaitQueueLength(c));
107 +        assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
108 +        assertEquals(threads.length, lock.getWaitingThreads(c).size());
109 +        assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
110 +                     new HashSet<Thread>(Arrays.asList(threads)));
111 +        lock.writeLock().unlock();
112 +    }
113 +
114 +    /**
115       * Constructor sets given fairness, and is in unlocked state
116       */
117      public void testConstructor() {
118 <        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
118 >        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
119          assertFalse(rl.isFair());
120          assertFalse(rl.isWriteLocked());
121          assertEquals(0, rl.getReadLockCount());
122 <        ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
122 >        ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
123          assertTrue(r2.isFair());
124          assertFalse(r2.isWriteLocked());
125          assertEquals(0, r2.getReadLockCount());
126 <        ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
126 >        ReentrantReadWriteLock r3 = new ReentrantReadWriteLock(false);
127          assertFalse(r3.isFair());
128          assertFalse(r3.isWriteLocked());
129          assertEquals(0, r3.getReadLockCount());
# Line 79 | Line 133 | public class ReentrantReadWriteLockTest
133       * write-locking and read-locking an unlocked lock succeed
134       */
135      public void testLock() {
136 <        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
136 >        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
137          rl.writeLock().lock();
138          assertTrue(rl.isWriteLocked());
139          assertTrue(rl.isWriteLockedByCurrentThread());
# Line 100 | Line 154 | public class ReentrantReadWriteLockTest
154          assertEquals(0, rl.getReadLockCount());
155      }
156  
103
157      /**
158       * locking an unlocked fair lock succeeds
159       */
160      public void testFairLock() {
161 <        ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
161 >        ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
162          rl.writeLock().lock();
163          assertTrue(rl.isWriteLocked());
164          assertTrue(rl.isWriteLockedByCurrentThread());
# Line 130 | Line 183 | public class ReentrantReadWriteLockTest
183       * getWriteHoldCount returns number of recursive holds
184       */
185      public void testGetWriteHoldCount() {
186 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
187 <        for (int i = 1; i <= SIZE; i++) {
188 <            lock.writeLock().lock();
189 <            assertEquals(i,lock.getWriteHoldCount());
190 <        }
191 <        for (int i = SIZE; i > 0; i--) {
192 <            lock.writeLock().unlock();
193 <            assertEquals(i-1,lock.getWriteHoldCount());
194 <        }
186 >        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
187 >        for (int i = 1; i <= SIZE; i++) {
188 >            lock.writeLock().lock();
189 >            assertEquals(i,lock.getWriteHoldCount());
190 >        }
191 >        for (int i = SIZE; i > 0; i--) {
192 >            lock.writeLock().unlock();
193 >            assertEquals(i-1,lock.getWriteHoldCount());
194 >        }
195      }
196  
197      /**
198       * WriteLock.getHoldCount returns number of recursive holds
199       */
200      public void testGetHoldCount() {
201 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
202 <        for (int i = 1; i <= SIZE; i++) {
203 <            lock.writeLock().lock();
204 <            assertEquals(i,lock.writeLock().getHoldCount());
205 <        }
206 <        for (int i = SIZE; i > 0; i--) {
207 <            lock.writeLock().unlock();
208 <            assertEquals(i-1,lock.writeLock().getHoldCount());
209 <        }
201 >        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
202 >        for (int i = 1; i <= SIZE; i++) {
203 >            lock.writeLock().lock();
204 >            assertEquals(i,lock.writeLock().getHoldCount());
205 >        }
206 >        for (int i = SIZE; i > 0; i--) {
207 >            lock.writeLock().unlock();
208 >            assertEquals(i-1,lock.writeLock().getHoldCount());
209 >        }
210      }
211  
212      /**
213       * getReadHoldCount returns number of recursive holds
214       */
215      public void testGetReadHoldCount() {
216 <        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
217 <        for (int i = 1; i <= SIZE; i++) {
218 <            lock.readLock().lock();
219 <            assertEquals(i,lock.getReadHoldCount());
220 <        }
221 <        for (int i = SIZE; i > 0; i--) {
222 <            lock.readLock().unlock();
223 <            assertEquals(i-1,lock.getReadHoldCount());
224 <        }
216 >        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
217 >        for (int i = 1; i <= SIZE; i++) {
218 >            lock.readLock().lock();
219 >            assertEquals(i,lock.getReadHoldCount());
220 >        }
221 >        for (int i = SIZE; i > 0; i--) {
222 >            lock.readLock().unlock();
223 >            assertEquals(i-1,lock.getReadHoldCount());
224 >        }
225      }
226  
174
227      /**
228       * write-unlocking an unlocked lock throws IllegalMonitorStateException
229       */
230 <    public void testUnlock_IllegalMonitorStateException() {
231 <        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
232 <        try {
233 <            rl.writeLock().unlock();
234 <            shouldThrow();
235 <        } catch (IllegalMonitorStateException success) {}
230 >    public void testWriteUnlock_IllegalMonitorStateException() {
231 >        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
232 >        try {
233 >            rl.writeLock().unlock();
234 >            shouldThrow();
235 >        } catch (IllegalMonitorStateException success) {}
236      }
237  
238 +    /**
239 +     * read-unlocking an unlocked lock throws IllegalMonitorStateException
240 +     */
241 +    public void testReadUnlock_IllegalMonitorStateException() {
242 +        ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
243 +        try {
244 +            rl.readLock().unlock();
245 +            shouldThrow();
246 +        } catch (IllegalMonitorStateException success) {}
247 +    }
248  
249      /**
250       * write-lockInterruptibly is interruptible
251       */
252      public void testWriteLockInterruptibly_Interrupted() throws Exception {
253 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
254 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
253 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
254 >        lock.writeLock().lock();
255 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
256              public void realRun() throws InterruptedException {
257                  lock.writeLock().lockInterruptibly();
195                lock.writeLock().unlock();
196                lock.writeLock().lockInterruptibly();
197                lock.writeLock().unlock();
258              }});
259  
260 <        lock.writeLock().lock();
201 <        t.start();
202 <        Thread.sleep(SHORT_DELAY_MS);
260 >        waitForQueuedThread(lock, t);
261          t.interrupt();
262 <        Thread.sleep(SHORT_DELAY_MS);
263 <        lock.writeLock().unlock();
206 <        t.join();
262 >        awaitTermination(t);
263 >        releaseWriteLock(lock);
264      }
265  
266      /**
267       * timed write-tryLock is interruptible
268       */
269      public void testWriteTryLock_Interrupted() throws InterruptedException {
270 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
271 <        lock.writeLock().lock();
272 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
270 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
271 >        lock.writeLock().lock();
272 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
273              public void realRun() throws InterruptedException {
274 <                lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
274 >                lock.writeLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
275              }});
276  
277 <        t.start();
277 >        waitForQueuedThread(lock, t);
278          t.interrupt();
279 <        lock.writeLock().unlock();
280 <        t.join();
279 >        awaitTermination(t);
280 >        releaseWriteLock(lock);
281      }
282  
283      /**
284       * read-lockInterruptibly is interruptible
285       */
286      public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
287 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
288 <        lock.writeLock().lock();
289 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
287 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
288 >        lock.writeLock().lock();
289 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
290              public void realRun() throws InterruptedException {
291                  lock.readLock().lockInterruptibly();
292              }});
293  
294 <        t.start();
238 <        Thread.sleep(SHORT_DELAY_MS);
294 >        waitForQueuedThread(lock, t);
295          t.interrupt();
296 <        Thread.sleep(SHORT_DELAY_MS);
297 <        lock.writeLock().unlock();
242 <        t.join();
296 >        awaitTermination(t);
297 >        releaseWriteLock(lock);
298      }
299  
300      /**
301       * timed read-tryLock is interruptible
302       */
303      public void testReadTryLock_Interrupted() throws InterruptedException {
304 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
305 <        lock.writeLock().lock();
306 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
304 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
305 >        lock.writeLock().lock();
306 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
307              public void realRun() throws InterruptedException {
308 <                lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
308 >                lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
309              }});
310  
311 <        t.start();
311 >        waitForQueuedThread(lock, t);
312          t.interrupt();
313 <        t.join();
313 >        awaitTermination(t);
314 >        releaseWriteLock(lock);
315      }
316  
261
317      /**
318       * write-tryLock fails if locked
319       */
320      public void testWriteTryLockWhenLocked() throws InterruptedException {
321 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
322 <        lock.writeLock().lock();
323 <        Thread t = new Thread(new Runnable() {
324 <                public void run() {
325 <                    threadAssertFalse(lock.writeLock().tryLock());
326 <                }
272 <            });
321 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
322 >        lock.writeLock().lock();
323 >        Thread t = newStartedThread(new CheckedRunnable() {
324 >            public void realRun() {
325 >                assertFalse(lock.writeLock().tryLock());
326 >            }});
327  
328 <        t.start();
329 <        t.join();
276 <        lock.writeLock().unlock();
328 >        awaitTermination(t);
329 >        releaseWriteLock(lock);
330      }
331  
332      /**
333       * read-tryLock fails if locked
334       */
335      public void testReadTryLockWhenLocked() throws InterruptedException {
336 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
337 <        lock.writeLock().lock();
338 <        Thread t = new Thread(new Runnable() {
339 <                public void run() {
340 <                    threadAssertFalse(lock.readLock().tryLock());
341 <                }
289 <            });
336 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
337 >        lock.writeLock().lock();
338 >        Thread t = newStartedThread(new CheckedRunnable() {
339 >            public void realRun() {
340 >                assertFalse(lock.readLock().tryLock());
341 >            }});
342  
343 <        t.start();
344 <        t.join();
293 <        lock.writeLock().unlock();
343 >        awaitTermination(t);
344 >        releaseWriteLock(lock);
345      }
346  
347      /**
348       * Multiple threads can hold a read lock when not write-locked
349       */
350      public void testMultipleReadLocks() throws InterruptedException {
351 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
352 <        lock.readLock().lock();
353 <        Thread t = new Thread(new Runnable() {
354 <                public void run() {
355 <                    threadAssertTrue(lock.readLock().tryLock());
356 <                    lock.readLock().unlock();
357 <                }
307 <            });
351 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
352 >        lock.readLock().lock();
353 >        Thread t = newStartedThread(new CheckedRunnable() {
354 >            public void realRun() {
355 >                assertTrue(lock.readLock().tryLock());
356 >                lock.readLock().unlock();
357 >            }});
358  
359 <        t.start();
310 <        t.join();
359 >        awaitTermination(t);
360          lock.readLock().unlock();
361      }
362  
363      /**
364 <     * A writelock succeeds after reading threads unlock
364 >     * A writelock succeeds only after reading threads unlock
365       */
366      public void testWriteAfterMultipleReadLocks() throws InterruptedException {
367 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
368 <        lock.readLock().lock();
369 <        Thread t1 = new Thread(new Runnable() {
370 <                public void run() {
371 <                    lock.readLock().lock();
372 <                    lock.readLock().unlock();
373 <                }
374 <            });
375 <        Thread t2 = new Thread(new Runnable() {
376 <                public void run() {
377 <                    lock.writeLock().lock();
378 <                    lock.writeLock().unlock();
330 <                }
331 <            });
367 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
368 >        lock.readLock().lock();
369 >        Thread t1 = newStartedThread(new CheckedRunnable() {
370 >            public void realRun() {
371 >                lock.readLock().lock();
372 >                lock.readLock().unlock();
373 >            }});
374 >        Thread t2 = newStartedThread(new CheckedRunnable() {
375 >            public void realRun() {
376 >                lock.writeLock().lock();
377 >                lock.writeLock().unlock();
378 >            }});
379  
380 <        t1.start();
381 <        t2.start();
382 <        Thread.sleep(SHORT_DELAY_MS);
380 >        awaitTermination(t1);
381 >        waitForQueuedThread(lock, t2);
382 >        assertNotWriteLocked(lock);
383          lock.readLock().unlock();
384 <        t1.join(MEDIUM_DELAY_MS);
338 <        t2.join(MEDIUM_DELAY_MS);
339 <        assertTrue(!t1.isAlive());
340 <        assertTrue(!t2.isAlive());
384 >        awaitTermination(t2);
385      }
386  
387      /**
388 <     * Readlocks succeed after a writing thread unlocks
388 >     * Readlocks succeed only after a writing thread unlocks
389       */
390      public void testReadAfterWriteLock() throws InterruptedException {
391 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
392 <        lock.writeLock().lock();
393 <        Thread t1 = new Thread(new Runnable() {
394 <                public void run() {
395 <                    lock.readLock().lock();
396 <                    lock.readLock().unlock();
397 <                }
398 <            });
399 <        Thread t2 = new Thread(new Runnable() {
400 <                public void run() {
401 <                    lock.readLock().lock();
402 <                    lock.readLock().unlock();
359 <                }
360 <            });
391 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
392 >        lock.writeLock().lock();
393 >        Thread t1 = newStartedThread(new CheckedRunnable() {
394 >            public void realRun() {
395 >                lock.readLock().lock();
396 >                lock.readLock().unlock();
397 >            }});
398 >        Thread t2 = newStartedThread(new CheckedRunnable() {
399 >            public void realRun() {
400 >                lock.readLock().lock();
401 >                lock.readLock().unlock();
402 >            }});
403  
404 <        t1.start();
405 <        t2.start();
406 <        Thread.sleep(SHORT_DELAY_MS);
407 <        lock.writeLock().unlock();
408 <        t1.join(MEDIUM_DELAY_MS);
367 <        t2.join(MEDIUM_DELAY_MS);
368 <        assertTrue(!t1.isAlive());
369 <        assertTrue(!t2.isAlive());
404 >        waitForQueuedThread(lock, t1);
405 >        waitForQueuedThread(lock, t2);
406 >        releaseWriteLock(lock);
407 >        awaitTermination(t1);
408 >        awaitTermination(t2);
409      }
410  
411      /**
412       * Read trylock succeeds if write locked by current thread
413       */
414      public void testReadHoldingWriteLock() {
415 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
416 <        lock.writeLock().lock();
415 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
416 >        lock.writeLock().lock();
417          assertTrue(lock.readLock().tryLock());
418          lock.readLock().unlock();
419          lock.writeLock().unlock();
# Line 385 | Line 424 | public class ReentrantReadWriteLockTest
424       * other threads are waiting for readlock
425       */
426      public void testReadHoldingWriteLock2() throws InterruptedException {
427 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
428 <        lock.writeLock().lock();
390 <        Thread t1 = new Thread(new Runnable() {
391 <                public void run() {
392 <                    lock.readLock().lock();
393 <                    lock.readLock().unlock();
394 <                }
395 <            });
396 <        Thread t2 = new Thread(new Runnable() {
397 <                public void run() {
398 <                    lock.readLock().lock();
399 <                    lock.readLock().unlock();
400 <                }
401 <            });
402 <
403 <        t1.start();
404 <        t2.start();
427 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
428 >        lock.writeLock().lock();
429          lock.readLock().lock();
430          lock.readLock().unlock();
431 <        Thread.sleep(SHORT_DELAY_MS);
431 >
432 >        Thread t1 = newStartedThread(new CheckedRunnable() {
433 >            public void realRun() {
434 >                lock.readLock().lock();
435 >                lock.readLock().unlock();
436 >            }});
437 >        Thread t2 = newStartedThread(new CheckedRunnable() {
438 >            public void realRun() {
439 >                lock.readLock().lock();
440 >                lock.readLock().unlock();
441 >            }});
442 >
443 >        waitForQueuedThread(lock, t1);
444 >        waitForQueuedThread(lock, t2);
445 >        assertTrue(lock.isWriteLockedByCurrentThread());
446          lock.readLock().lock();
447          lock.readLock().unlock();
448 <        lock.writeLock().unlock();
449 <        t1.join(MEDIUM_DELAY_MS);
450 <        t2.join(MEDIUM_DELAY_MS);
413 <        assertTrue(!t1.isAlive());
414 <        assertTrue(!t2.isAlive());
448 >        releaseWriteLock(lock);
449 >        awaitTermination(t1);
450 >        awaitTermination(t2);
451      }
452  
453      /**
454 <     *  Read lock succeeds if write locked by current thread even if
454 >     * Read lock succeeds if write locked by current thread even if
455       * other threads are waiting for writelock
456       */
457      public void testReadHoldingWriteLock3() throws InterruptedException {
458 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
459 <        lock.writeLock().lock();
424 <        Thread t1 = new Thread(new Runnable() {
425 <                public void run() {
426 <                    lock.writeLock().lock();
427 <                    lock.writeLock().unlock();
428 <                }
429 <            });
430 <        Thread t2 = new Thread(new Runnable() {
431 <                public void run() {
432 <                    lock.writeLock().lock();
433 <                    lock.writeLock().unlock();
434 <                }
435 <            });
436 <
437 <        t1.start();
438 <        t2.start();
458 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
459 >        lock.writeLock().lock();
460          lock.readLock().lock();
461          lock.readLock().unlock();
462 <        Thread.sleep(SHORT_DELAY_MS);
462 >
463 >        Thread t1 = newStartedThread(new CheckedRunnable() {
464 >            public void realRun() {
465 >                lock.writeLock().lock();
466 >                lock.writeLock().unlock();
467 >            }});
468 >        Thread t2 = newStartedThread(new CheckedRunnable() {
469 >            public void realRun() {
470 >                lock.writeLock().lock();
471 >                lock.writeLock().unlock();
472 >            }});
473 >
474 >        waitForQueuedThread(lock, t1);
475 >        waitForQueuedThread(lock, t2);
476 >        assertTrue(lock.isWriteLockedByCurrentThread());
477          lock.readLock().lock();
478          lock.readLock().unlock();
479 <        lock.writeLock().unlock();
480 <        t1.join(MEDIUM_DELAY_MS);
481 <        t2.join(MEDIUM_DELAY_MS);
447 <        assertTrue(!t1.isAlive());
448 <        assertTrue(!t2.isAlive());
479 >        releaseWriteLock(lock);
480 >        awaitTermination(t1);
481 >        awaitTermination(t2);
482      }
483  
451
484      /**
485 <     *  Write lock succeeds if write locked by current thread even if
485 >     * Write lock succeeds if write locked by current thread even if
486       * other threads are waiting for writelock
487       */
488      public void testWriteHoldingWriteLock4() throws InterruptedException {
489 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
458 <        lock.writeLock().lock();
459 <        Thread t1 = new Thread(new Runnable() {
460 <                public void run() {
461 <                    lock.writeLock().lock();
462 <                    lock.writeLock().unlock();
463 <                }
464 <            });
465 <        Thread t2 = new Thread(new Runnable() {
466 <                public void run() {
467 <                    lock.writeLock().lock();
468 <                    lock.writeLock().unlock();
469 <                }
470 <            });
471 <
472 <        t1.start();
473 <        t2.start();
489 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
490          lock.writeLock().lock();
475        lock.writeLock().unlock();
476        Thread.sleep(SHORT_DELAY_MS);
491          lock.writeLock().lock();
492          lock.writeLock().unlock();
493 +
494 +        Thread t1 = newStartedThread(new CheckedRunnable() {
495 +            public void realRun() {
496 +                lock.writeLock().lock();
497 +                lock.writeLock().unlock();
498 +            }});
499 +        Thread t2 = newStartedThread(new CheckedRunnable() {
500 +            public void realRun() {
501 +                lock.writeLock().lock();
502 +                lock.writeLock().unlock();
503 +            }});
504 +
505 +        waitForQueuedThread(lock, t1);
506 +        waitForQueuedThread(lock, t2);
507 +        assertTrue(lock.isWriteLockedByCurrentThread());
508 +        assertEquals(1, lock.getWriteHoldCount());
509 +        lock.writeLock().lock();
510 +        assertTrue(lock.isWriteLockedByCurrentThread());
511 +        assertEquals(2, lock.getWriteHoldCount());
512          lock.writeLock().unlock();
513 <        t1.join(MEDIUM_DELAY_MS);
514 <        t2.join(MEDIUM_DELAY_MS);
515 <        assertTrue(!t1.isAlive());
483 <        assertTrue(!t2.isAlive());
513 >        releaseWriteLock(lock);
514 >        awaitTermination(t1);
515 >        awaitTermination(t2);
516      }
517  
486
518      /**
519       * Fair Read trylock succeeds if write locked by current thread
520       */
521      public void testReadHoldingWriteLockFair() {
522 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
523 <        lock.writeLock().lock();
522 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
523 >        lock.writeLock().lock();
524          assertTrue(lock.readLock().tryLock());
525          lock.readLock().unlock();
526          lock.writeLock().unlock();
# Line 500 | Line 531 | public class ReentrantReadWriteLockTest
531       * other threads are waiting for readlock
532       */
533      public void testReadHoldingWriteLockFair2() throws InterruptedException {
534 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
535 <        lock.writeLock().lock();
505 <        Thread t1 = new Thread(new Runnable() {
506 <                public void run() {
507 <                    lock.readLock().lock();
508 <                    lock.readLock().unlock();
509 <                }
510 <            });
511 <        Thread t2 = new Thread(new Runnable() {
512 <                public void run() {
513 <                    lock.readLock().lock();
514 <                    lock.readLock().unlock();
515 <                }
516 <            });
517 <
518 <        t1.start();
519 <        t2.start();
534 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
535 >        lock.writeLock().lock();
536          lock.readLock().lock();
537          lock.readLock().unlock();
538 <        Thread.sleep(SHORT_DELAY_MS);
538 >
539 >        Thread t1 = newStartedThread(new CheckedRunnable() {
540 >            public void realRun() {
541 >                lock.readLock().lock();
542 >                lock.readLock().unlock();
543 >            }});
544 >        Thread t2 = newStartedThread(new CheckedRunnable() {
545 >            public void realRun() {
546 >                lock.readLock().lock();
547 >                lock.readLock().unlock();
548 >            }});
549 >
550 >        waitForQueuedThread(lock, t1);
551 >        waitForQueuedThread(lock, t2);
552 >        assertTrue(lock.isWriteLockedByCurrentThread());
553          lock.readLock().lock();
554          lock.readLock().unlock();
555 <        lock.writeLock().unlock();
556 <        t1.join(MEDIUM_DELAY_MS);
557 <        t2.join(MEDIUM_DELAY_MS);
528 <        assertTrue(!t1.isAlive());
529 <        assertTrue(!t2.isAlive());
555 >        releaseWriteLock(lock);
556 >        awaitTermination(t1);
557 >        awaitTermination(t2);
558      }
559  
532
560      /**
561       * Fair Read lock succeeds if write locked by current thread even if
562       * other threads are waiting for writelock
563       */
564      public void testReadHoldingWriteLockFair3() throws InterruptedException {
565 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
566 <        lock.writeLock().lock();
540 <        Thread t1 = new Thread(new Runnable() {
541 <                public void run() {
542 <                    lock.writeLock().lock();
543 <                    lock.writeLock().unlock();
544 <                }
545 <            });
546 <        Thread t2 = new Thread(new Runnable() {
547 <                public void run() {
548 <                    lock.writeLock().lock();
549 <                    lock.writeLock().unlock();
550 <                }
551 <            });
552 <
553 <        t1.start();
554 <        t2.start();
565 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
566 >        lock.writeLock().lock();
567          lock.readLock().lock();
568          lock.readLock().unlock();
569 <        Thread.sleep(SHORT_DELAY_MS);
569 >
570 >        Thread t1 = newStartedThread(new CheckedRunnable() {
571 >            public void realRun() {
572 >                lock.writeLock().lock();
573 >                lock.writeLock().unlock();
574 >            }});
575 >        Thread t2 = newStartedThread(new CheckedRunnable() {
576 >            public void realRun() {
577 >                lock.writeLock().lock();
578 >                lock.writeLock().unlock();
579 >            }});
580 >
581 >        waitForQueuedThread(lock, t1);
582 >        waitForQueuedThread(lock, t2);
583 >        assertTrue(lock.isWriteLockedByCurrentThread());
584          lock.readLock().lock();
585          lock.readLock().unlock();
586 <        lock.writeLock().unlock();
587 <        t1.join(MEDIUM_DELAY_MS);
588 <        t2.join(MEDIUM_DELAY_MS);
563 <        assertTrue(!t1.isAlive());
564 <        assertTrue(!t2.isAlive());
586 >        releaseWriteLock(lock);
587 >        awaitTermination(t1);
588 >        awaitTermination(t2);
589      }
590  
567
591      /**
592       * Fair Write lock succeeds if write locked by current thread even if
593       * other threads are waiting for writelock
594       */
595      public void testWriteHoldingWriteLockFair4() throws InterruptedException {
596 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
597 <        lock.writeLock().lock();
598 <        Thread t1 = new Thread(new Runnable() {
599 <                public void run() {
600 <                    lock.writeLock().lock();
601 <                    lock.writeLock().unlock();
602 <                }
603 <            });
604 <        Thread t2 = new Thread(new Runnable() {
605 <                public void run() {
606 <                    lock.writeLock().lock();
607 <                    lock.writeLock().unlock();
585 <                }
586 <            });
596 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
597 >        lock.writeLock().lock();
598 >        Thread t1 = newStartedThread(new CheckedRunnable() {
599 >            public void realRun() {
600 >                lock.writeLock().lock();
601 >                lock.writeLock().unlock();
602 >            }});
603 >        Thread t2 = newStartedThread(new CheckedRunnable() {
604 >            public void realRun() {
605 >                lock.writeLock().lock();
606 >                lock.writeLock().unlock();
607 >            }});
608  
609 <        t1.start();
610 <        t2.start();
590 <        Thread.sleep(SHORT_DELAY_MS);
609 >        waitForQueuedThread(lock, t1);
610 >        waitForQueuedThread(lock, t2);
611          assertTrue(lock.isWriteLockedByCurrentThread());
612 <        assertTrue(lock.getWriteHoldCount() == 1);
612 >        assertEquals(1, lock.getWriteHoldCount());
613          lock.writeLock().lock();
614 <        assertTrue(lock.getWriteHoldCount() == 2);
614 >        assertEquals(2, lock.getWriteHoldCount());
615          lock.writeLock().unlock();
616          lock.writeLock().lock();
617          lock.writeLock().unlock();
618 <        lock.writeLock().unlock();
619 <        t1.join(MEDIUM_DELAY_MS);
620 <        t2.join(MEDIUM_DELAY_MS);
601 <        assertTrue(!t1.isAlive());
602 <        assertTrue(!t2.isAlive());
618 >        releaseWriteLock(lock);
619 >        awaitTermination(t1);
620 >        awaitTermination(t2);
621      }
622  
605
623      /**
624       * Read tryLock succeeds if readlocked but not writelocked
625       */
626      public void testTryLockWhenReadLocked() throws InterruptedException {
627 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
628 <        lock.readLock().lock();
629 <        Thread t = new Thread(new Runnable() {
630 <                public void run() {
631 <                    threadAssertTrue(lock.readLock().tryLock());
632 <                    lock.readLock().unlock();
633 <                }
617 <            });
627 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
628 >        lock.readLock().lock();
629 >        Thread t = newStartedThread(new CheckedRunnable() {
630 >            public void realRun() {
631 >                assertTrue(lock.readLock().tryLock());
632 >                lock.readLock().unlock();
633 >            }});
634  
635 <        t.start();
620 <        t.join();
635 >        awaitTermination(t);
636          lock.readLock().unlock();
637      }
638  
624
625
639      /**
640       * write tryLock fails when readlocked
641       */
642      public void testWriteTryLockWhenReadLocked() throws InterruptedException {
643 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
644 <        lock.readLock().lock();
645 <        Thread t = new Thread(new Runnable() {
646 <                public void run() {
647 <                    threadAssertFalse(lock.writeLock().tryLock());
648 <                }
636 <            });
643 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
644 >        lock.readLock().lock();
645 >        Thread t = newStartedThread(new CheckedRunnable() {
646 >            public void realRun() {
647 >                assertFalse(lock.writeLock().tryLock());
648 >            }});
649  
650 <        t.start();
639 <        t.join();
650 >        awaitTermination(t);
651          lock.readLock().unlock();
652      }
653  
643
654      /**
655       * Fair Read tryLock succeeds if readlocked but not writelocked
656       */
657      public void testTryLockWhenReadLockedFair() throws InterruptedException {
658 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
659 <        lock.readLock().lock();
660 <        Thread t = new Thread(new Runnable() {
661 <                public void run() {
662 <                    threadAssertTrue(lock.readLock().tryLock());
663 <                    lock.readLock().unlock();
664 <                }
655 <            });
658 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
659 >        lock.readLock().lock();
660 >        Thread t = newStartedThread(new CheckedRunnable() {
661 >            public void realRun() {
662 >                assertTrue(lock.readLock().tryLock());
663 >                lock.readLock().unlock();
664 >            }});
665  
666 <        t.start();
658 <        t.join();
666 >        awaitTermination(t);
667          lock.readLock().unlock();
668      }
669  
662
663
670      /**
671       * Fair write tryLock fails when readlocked
672       */
673      public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
674 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
675 <        lock.readLock().lock();
676 <        Thread t = new Thread(new Runnable() {
677 <                public void run() {
678 <                    threadAssertFalse(lock.writeLock().tryLock());
679 <                }
674 <            });
674 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
675 >        lock.readLock().lock();
676 >        Thread t = newStartedThread(new CheckedRunnable() {
677 >            public void realRun() {
678 >                assertFalse(lock.writeLock().tryLock());
679 >            }});
680  
681 <        t.start();
677 <        t.join();
681 >        awaitTermination(t);
682          lock.readLock().unlock();
683      }
684  
681
682
685      /**
686       * write timed tryLock times out if locked
687       */
688      public void testWriteTryLock_Timeout() throws InterruptedException {
689 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
690 <        lock.writeLock().lock();
691 <        Thread t = new Thread(new CheckedRunnable() {
689 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
690 >        lock.writeLock().lock();
691 >        Thread t = newStartedThread(new CheckedRunnable() {
692              public void realRun() throws InterruptedException {
693 <                threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
693 >                assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
694              }});
695  
696 <        t.start();
695 <        t.join();
696 >        awaitTermination(t);
697          assertTrue(lock.writeLock().isHeldByCurrentThread());
698          lock.writeLock().unlock();
699      }
# Line 701 | Line 702 | public class ReentrantReadWriteLockTest
702       * read timed tryLock times out if write-locked
703       */
704      public void testReadTryLock_Timeout() throws InterruptedException {
705 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
706 <        lock.writeLock().lock();
707 <        Thread t = new Thread(new CheckedRunnable() {
705 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
706 >        lock.writeLock().lock();
707 >        Thread t = newStartedThread(new CheckedRunnable() {
708              public void realRun() throws InterruptedException {
709 <                threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
709 >                assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
710              }});
711  
712 <        t.start();
712 <        t.join();
712 >        awaitTermination(t);
713          assertTrue(lock.writeLock().isHeldByCurrentThread());
714          lock.writeLock().unlock();
715      }
716  
717
717      /**
718       * write lockInterruptibly succeeds if lock free else is interruptible
719       */
720      public void testWriteLockInterruptibly() throws InterruptedException {
721 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
721 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
722          lock.writeLock().lockInterruptibly();
723 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
723 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
724              public void realRun() throws InterruptedException {
725                  lock.writeLock().lockInterruptibly();
726              }});
727  
728 <        t.start();
730 <        Thread.sleep(SHORT_DELAY_MS);
728 >        waitForQueuedThread(lock, t);
729          t.interrupt();
730 <        Thread.sleep(SHORT_DELAY_MS);
731 <        t.join();
734 <        lock.writeLock().unlock();
730 >        awaitTermination(t);
731 >        releaseWriteLock(lock);
732      }
733  
734      /**
735 <     *  read lockInterruptibly succeeds if lock free else is interruptible
735 >     * read lockInterruptibly succeeds if lock free else is interruptible
736       */
737      public void testReadLockInterruptibly() throws InterruptedException {
738 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
738 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
739          lock.writeLock().lockInterruptibly();
740 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
740 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
741              public void realRun() throws InterruptedException {
742                  lock.readLock().lockInterruptibly();
743              }});
744  
745 <        t.start();
749 <        Thread.sleep(SHORT_DELAY_MS);
745 >        waitForQueuedThread(lock, t);
746          t.interrupt();
747 <        t.join();
748 <        lock.writeLock().unlock();
747 >        awaitTermination(t);
748 >        releaseWriteLock(lock);
749      }
750  
751      /**
752       * Calling await without holding lock throws IllegalMonitorStateException
753       */
754      public void testAwait_IllegalMonitor() throws InterruptedException {
755 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
755 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
756          final Condition c = lock.writeLock().newCondition();
757          try {
758              c.await();
759              shouldThrow();
760          } catch (IllegalMonitorStateException success) {}
761 +        try {
762 +            c.await(LONG_DELAY_MS, MILLISECONDS);
763 +            shouldThrow();
764 +        } catch (IllegalMonitorStateException success) {}
765 +        try {
766 +            c.awaitNanos(100);
767 +            shouldThrow();
768 +        } catch (IllegalMonitorStateException success) {}
769 +        try {
770 +            c.awaitUninterruptibly();
771 +            shouldThrow();
772 +        } catch (IllegalMonitorStateException success) {}
773      }
774  
775      /**
776       * Calling signal without holding lock throws IllegalMonitorStateException
777       */
778      public void testSignal_IllegalMonitor() {
779 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
779 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
780          final Condition c = lock.writeLock().newCondition();
781          try {
782              c.signal();
# Line 777 | Line 785 | public class ReentrantReadWriteLockTest
785      }
786  
787      /**
788 +     * Calling signalAll without holding lock throws IllegalMonitorStateException
789 +     */
790 +    public void testSignalAll_IllegalMonitor() {
791 +        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
792 +        final Condition c = lock.writeLock().newCondition();
793 +        try {
794 +            c.signalAll();
795 +            shouldThrow();
796 +        } catch (IllegalMonitorStateException success) {}
797 +    }
798 +
799 +    /**
800       * awaitNanos without a signal times out
801       */
802      public void testAwaitNanos_Timeout() throws InterruptedException {
803 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
803 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
804          final Condition c = lock.writeLock().newCondition();
785
805          lock.writeLock().lock();
806 <        long t = c.awaitNanos(100);
807 <        assertTrue(t <= 0);
806 >        long startTime = System.nanoTime();
807 >        long timeoutMillis = 10;
808 >        long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
809 >        long nanosRemaining = c.awaitNanos(timeoutNanos);
810 >        assertTrue(nanosRemaining <= 0);
811 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
812          lock.writeLock().unlock();
813      }
814  
792
815      /**
816 <     *  timed await without a signal times out
816 >     * timed await without a signal times out
817       */
818      public void testAwait_Timeout() throws InterruptedException {
819 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
819 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
820          final Condition c = lock.writeLock().newCondition();
821          lock.writeLock().lock();
822 <        assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
822 >        long startTime = System.nanoTime();
823 >        long timeoutMillis = 10;
824 >        assertFalse(c.await(timeoutMillis, MILLISECONDS));
825 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
826          lock.writeLock().unlock();
827      }
828  
# Line 805 | Line 830 | public class ReentrantReadWriteLockTest
830       * awaitUntil without a signal times out
831       */
832      public void testAwaitUntil_Timeout() throws InterruptedException {
833 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
833 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
834          final Condition c = lock.writeLock().newCondition();
835          lock.writeLock().lock();
836          java.util.Date d = new java.util.Date();
# Line 817 | Line 842 | public class ReentrantReadWriteLockTest
842       * await returns when signalled
843       */
844      public void testAwait() throws InterruptedException {
845 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
845 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
846          final Condition c = lock.writeLock().newCondition();
847 <        Thread t = new Thread(new CheckedRunnable() {
847 >        final CountDownLatch locked = new CountDownLatch(1);
848 >        Thread t = newStartedThread(new CheckedRunnable() {
849              public void realRun() throws InterruptedException {
850                  lock.writeLock().lock();
851 +                locked.countDown();
852                  c.await();
853                  lock.writeLock().unlock();
854              }});
855  
856 <        t.start();
830 <        Thread.sleep(SHORT_DELAY_MS);
856 >        locked.await();
857          lock.writeLock().lock();
858          c.signal();
859 +        assertTrue(t.isAlive());
860          lock.writeLock().unlock();
861 <        t.join(SHORT_DELAY_MS);
835 <        assertFalse(t.isAlive());
836 <    }
837 <
838 <    /** A helper class for uninterruptible wait tests */
839 <    class UninterruptableThread extends Thread {
840 <        private Lock lock;
841 <        private Condition c;
842 <
843 <        public volatile boolean canAwake = false;
844 <        public volatile boolean interrupted = false;
845 <        public volatile boolean lockStarted = false;
846 <
847 <        public UninterruptableThread(Lock lock, Condition c) {
848 <            this.lock = lock;
849 <            this.c = c;
850 <        }
851 <
852 <        public synchronized void run() {
853 <            lock.lock();
854 <            lockStarted = true;
855 <
856 <            while (!canAwake) {
857 <                c.awaitUninterruptibly();
858 <            }
859 <
860 <            interrupted = isInterrupted();
861 <            lock.unlock();
862 <        }
861 >        awaitTermination(t);
862      }
863  
864      /**
# Line 868 | Line 867 | public class ReentrantReadWriteLockTest
867      public void testAwaitUninterruptibly() throws InterruptedException {
868          final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
869          final Condition c = lock.writeLock().newCondition();
870 <        UninterruptableThread thread = new UninterruptableThread(lock.writeLock(), c);
871 <
872 <        thread.start();
873 <
874 <        while (!thread.lockStarted) {
875 <            Thread.sleep(100);
876 <        }
870 >        final CountDownLatch locked = new CountDownLatch(1);
871 >        final AtomicBoolean canAwake = new AtomicBoolean(false);
872 >        Thread t = newStartedThread(new CheckedRunnable() {
873 >            public void realRun() {
874 >                lock.writeLock().lock();
875 >                locked.countDown();
876 >                c.awaitUninterruptibly();
877 >                assertTrue(Thread.interrupted());
878 >                lock.writeLock().unlock();
879 >            }});
880  
881 +        locked.await();
882          lock.writeLock().lock();
883 <        try {
884 <            thread.interrupt();
885 <            thread.canAwake = true;
886 <            c.signal();
887 <        } finally {
888 <            lock.writeLock().unlock();
889 <        }
890 <
888 <        thread.join();
889 <        assertTrue(thread.interrupted);
890 <        assertFalse(thread.isAlive());
883 >        lock.writeLock().unlock();
884 >        t.interrupt();
885 >        t.join(10);
886 >        assertTrue(t.isAlive());
887 >        lock.writeLock().lock();
888 >        c.signal();
889 >        lock.writeLock().unlock();
890 >        awaitTermination(t);
891      }
892  
893      /**
894       * await is interruptible
895       */
896      public void testAwait_Interrupt() throws InterruptedException {
897 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
897 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
898          final Condition c = lock.writeLock().newCondition();
899 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
899 >        final CountDownLatch locked = new CountDownLatch(1);
900 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
901              public void realRun() throws InterruptedException {
902                  lock.writeLock().lock();
903 <                c.await();
904 <                lock.writeLock().unlock();
903 >                assertTrue(lock.isWriteLocked());
904 >                assertTrue(lock.isWriteLockedByCurrentThread());
905 >                assertHasNoWaiters(lock, c);
906 >                locked.countDown();
907 >                try {
908 >                    c.await();
909 >                } finally {
910 >                    assertTrue(lock.isWriteLocked());
911 >                    assertTrue(lock.isWriteLockedByCurrentThread());
912 >                    assertHasNoWaiters(lock, c);
913 >                    lock.writeLock().unlock();
914 >                    assertFalse(Thread.interrupted());
915 >                }
916              }});
917  
918 <        t.start();
919 <        Thread.sleep(SHORT_DELAY_MS);
918 >        locked.await();
919 >        assertHasWaiters(lock, c, t);
920          t.interrupt();
921 <        t.join(SHORT_DELAY_MS);
922 <        assertFalse(t.isAlive());
921 >        awaitTermination(t);
922 >        assertFalse(lock.isWriteLocked());
923      }
924  
925      /**
926       * awaitNanos is interruptible
927       */
928      public void testAwaitNanos_Interrupt() throws InterruptedException {
929 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
929 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
930          final Condition c = lock.writeLock().newCondition();
931 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
931 >        final CountDownLatch locked = new CountDownLatch(1);
932 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
933              public void realRun() throws InterruptedException {
934                  lock.writeLock().lock();
935 <                c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
936 <                lock.writeLock().unlock();
935 >                assertTrue(lock.isWriteLocked());
936 >                assertTrue(lock.isWriteLockedByCurrentThread());
937 >                assertHasNoWaiters(lock, c);
938 >                locked.countDown();
939 >                try {
940 >                    c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS));
941 >                } finally {
942 >                    assertTrue(lock.isWriteLocked());
943 >                    assertTrue(lock.isWriteLockedByCurrentThread());
944 >                    assertHasNoWaiters(lock, c);
945 >                    lock.writeLock().unlock();
946 >                    assertFalse(Thread.interrupted());
947 >                }
948              }});
949  
950 <        t.start();
951 <        Thread.sleep(SHORT_DELAY_MS);
950 >        locked.await();
951 >        assertHasWaiters(lock, c, t);
952          t.interrupt();
953 <        t.join(SHORT_DELAY_MS);
954 <        assertFalse(t.isAlive());
953 >        awaitTermination(t);
954 >        assertFalse(lock.isWriteLocked());
955      }
956  
957      /**
958       * awaitUntil is interruptible
959       */
960      public void testAwaitUntil_Interrupt() throws InterruptedException {
961 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
961 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
962          final Condition c = lock.writeLock().newCondition();
963 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
963 >        final CountDownLatch locked = new CountDownLatch(1);
964 >        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
965              public void realRun() throws InterruptedException {
966                  lock.writeLock().lock();
967 +                assertTrue(lock.isWriteLocked());
968 +                assertTrue(lock.isWriteLockedByCurrentThread());
969 +                assertHasNoWaiters(lock, c);
970 +                locked.countDown();
971                  java.util.Date d = new java.util.Date();
972 <                c.awaitUntil(new java.util.Date(d.getTime() + 10000));
973 <                lock.writeLock().unlock();
972 >                try {
973 >                    c.awaitUntil(new java.util.Date(d.getTime() + 10000));
974 >                } finally {
975 >                    assertTrue(lock.isWriteLocked());
976 >                    assertTrue(lock.isWriteLockedByCurrentThread());
977 >                    assertHasNoWaiters(lock, c);
978 >                    lock.writeLock().unlock();
979 >                    assertFalse(Thread.interrupted());
980 >                }
981              }});
982  
983 <        t.start();
984 <        Thread.sleep(SHORT_DELAY_MS);
983 >        locked.await();
984 >        assertHasWaiters(lock, c, t);
985          t.interrupt();
986 <        t.join(SHORT_DELAY_MS);
987 <        assertFalse(t.isAlive());
986 >        awaitTermination(t);
987 >        assertFalse(lock.isWriteLocked());
988      }
989  
990      /**
991       * signalAll wakes up all threads
992       */
993      public void testSignalAll() throws InterruptedException {
994 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
994 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
995          final Condition c = lock.writeLock().newCondition();
996 <        Thread t1 = new Thread(new CheckedRunnable() {
996 >        final CountDownLatch locked = new CountDownLatch(2);
997 >        final Lock writeLock = lock.writeLock();
998 >        Thread t1 = newStartedThread(new CheckedRunnable() {
999              public void realRun() throws InterruptedException {
1000 <                lock.writeLock().lock();
1000 >                writeLock.lock();
1001 >                locked.countDown();
1002                  c.await();
1003 <                lock.writeLock().unlock();
1003 >                writeLock.unlock();
1004              }});
1005  
1006 <        Thread t2 = new Thread(new CheckedRunnable() {
1006 >        Thread t2 = newStartedThread(new CheckedRunnable() {
1007              public void realRun() throws InterruptedException {
1008 <                lock.writeLock().lock();
1008 >                writeLock.lock();
1009 >                locked.countDown();
1010                  c.await();
1011 <                lock.writeLock().unlock();
1011 >                writeLock.unlock();
1012              }});
1013  
1014 <        t1.start();
1015 <        t2.start();
1016 <        Thread.sleep(SHORT_DELAY_MS);
977 <        lock.writeLock().lock();
1014 >        locked.await();
1015 >        writeLock.lock();
1016 >        assertHasWaiters(lock, c, t1, t2);
1017          c.signalAll();
1018 <        lock.writeLock().unlock();
1019 <        t1.join(SHORT_DELAY_MS);
1020 <        t2.join(SHORT_DELAY_MS);
1021 <        assertFalse(t1.isAlive());
1022 <        assertFalse(t2.isAlive());
1018 >        assertHasNoWaiters(lock, c);
1019 >        writeLock.unlock();
1020 >        awaitTermination(t1);
1021 >        awaitTermination(t2);
1022 >    }
1023 >
1024 >    /**
1025 >     * signal wakes up waiting threads in FIFO order.
1026 >     */
1027 >    public void testSignalWakesFifo() throws InterruptedException {
1028 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1029 >        final Condition c = lock.writeLock().newCondition();
1030 >        final CountDownLatch locked1 = new CountDownLatch(1);
1031 >        final CountDownLatch locked2 = new CountDownLatch(1);
1032 >        final Lock writeLock = lock.writeLock();
1033 >        Thread t1 = newStartedThread(new CheckedRunnable() {
1034 >            public void realRun() throws InterruptedException {
1035 >                writeLock.lock();
1036 >                locked1.countDown();
1037 >                c.await();
1038 >                writeLock.unlock();
1039 >            }});
1040 >
1041 >        locked1.await();
1042 >
1043 >        Thread t2 = newStartedThread(new CheckedRunnable() {
1044 >            public void realRun() throws InterruptedException {
1045 >                writeLock.lock();
1046 >                locked2.countDown();
1047 >                c.await();
1048 >                writeLock.unlock();
1049 >            }});
1050 >
1051 >        locked2.await();
1052 >
1053 >        writeLock.lock();
1054 >        assertHasWaiters(lock, c, t1, t2);
1055 >        assertFalse(lock.hasQueuedThreads());
1056 >        c.signal();
1057 >        assertHasWaiters(lock, c, t2);
1058 >        assertTrue(lock.hasQueuedThread(t1));
1059 >        assertFalse(lock.hasQueuedThread(t2));
1060 >        c.signal();
1061 >        assertHasNoWaiters(lock, c);
1062 >        assertTrue(lock.hasQueuedThread(t1));
1063 >        assertTrue(lock.hasQueuedThread(t2));
1064 >        writeLock.unlock();
1065 >        awaitTermination(t1);
1066 >        awaitTermination(t2);
1067      }
1068  
1069      /**
# Line 1007 | Line 1090 | public class ReentrantReadWriteLockTest
1090       * hasQueuedThreads reports whether there are waiting threads
1091       */
1092      public void testhasQueuedThreads() throws InterruptedException {
1093 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1093 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1094          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1095          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1096          assertFalse(lock.hasQueuedThreads());
1097          lock.writeLock().lock();
1098 +        assertFalse(lock.hasQueuedThreads());
1099 +        long startTime = System.nanoTime();
1100          t1.start();
1101 <        Thread.sleep(SHORT_DELAY_MS);
1017 <        assertTrue(lock.hasQueuedThreads());
1101 >        waitForQueuedThread(lock, t1);
1102          t2.start();
1103 <        Thread.sleep(SHORT_DELAY_MS);
1103 >        waitForQueuedThread(lock, t2);
1104          assertTrue(lock.hasQueuedThreads());
1105          t1.interrupt();
1106 <        Thread.sleep(SHORT_DELAY_MS);
1106 >        awaitTermination(t1);
1107          assertTrue(lock.hasQueuedThreads());
1108          lock.writeLock().unlock();
1109 <        Thread.sleep(SHORT_DELAY_MS);
1109 >        awaitTermination(t2);
1110          assertFalse(lock.hasQueuedThreads());
1027        t1.join();
1028        t2.join();
1111      }
1112  
1113      /**
1114       * hasQueuedThread(null) throws NPE
1115       */
1116      public void testHasQueuedThreadNPE() {
1117 <        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1117 >        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1118          try {
1119              sync.hasQueuedThread(null);
1120              shouldThrow();
# Line 1043 | Line 1125 | public class ReentrantReadWriteLockTest
1125       * hasQueuedThread reports whether a thread is queued.
1126       */
1127      public void testHasQueuedThread() throws InterruptedException {
1128 <        final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
1129 <        Thread t1 = new Thread(new InterruptedLockRunnable(sync));
1130 <        Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
1131 <        assertFalse(sync.hasQueuedThread(t1));
1132 <        assertFalse(sync.hasQueuedThread(t2));
1133 <        sync.writeLock().lock();
1128 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1129 >        Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1130 >        Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1131 >        assertFalse(lock.hasQueuedThread(t1));
1132 >        assertFalse(lock.hasQueuedThread(t2));
1133 >        lock.writeLock().lock();
1134 >        long startTime = System.nanoTime();
1135          t1.start();
1136 <        Thread.sleep(SHORT_DELAY_MS);
1137 <        assertTrue(sync.hasQueuedThread(t1));
1136 >        waitForQueuedThread(lock, t1);
1137 >        assertTrue(lock.hasQueuedThread(t1));
1138 >        assertFalse(lock.hasQueuedThread(t2));
1139          t2.start();
1140 <        Thread.sleep(SHORT_DELAY_MS);
1141 <        assertTrue(sync.hasQueuedThread(t1));
1142 <        assertTrue(sync.hasQueuedThread(t2));
1140 >        waitForQueuedThread(lock, t2);
1141 >        assertTrue(lock.hasQueuedThread(t1));
1142 >        assertTrue(lock.hasQueuedThread(t2));
1143          t1.interrupt();
1144 <        Thread.sleep(SHORT_DELAY_MS);
1145 <        assertFalse(sync.hasQueuedThread(t1));
1146 <        assertTrue(sync.hasQueuedThread(t2));
1147 <        sync.writeLock().unlock();
1148 <        Thread.sleep(SHORT_DELAY_MS);
1149 <        assertFalse(sync.hasQueuedThread(t1));
1150 <        Thread.sleep(SHORT_DELAY_MS);
1067 <        assertFalse(sync.hasQueuedThread(t2));
1068 <        t1.join();
1069 <        t2.join();
1144 >        awaitTermination(t1);
1145 >        assertFalse(lock.hasQueuedThread(t1));
1146 >        assertTrue(lock.hasQueuedThread(t2));
1147 >        lock.writeLock().unlock();
1148 >        awaitTermination(t2);
1149 >        assertFalse(lock.hasQueuedThread(t1));
1150 >        assertFalse(lock.hasQueuedThread(t2));
1151      }
1152  
1072
1153      /**
1154       * getQueueLength reports number of waiting threads
1155       */
1156      public void testGetQueueLength() throws InterruptedException {
1157 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1157 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1158          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1159          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1160          assertEquals(0, lock.getQueueLength());
1161          lock.writeLock().lock();
1162 +        long startTime = System.nanoTime();
1163          t1.start();
1164 <        Thread.sleep(SHORT_DELAY_MS);
1164 >        waitForQueuedThread(lock, t1);
1165          assertEquals(1, lock.getQueueLength());
1166          t2.start();
1167 <        Thread.sleep(SHORT_DELAY_MS);
1167 >        waitForQueuedThread(lock, t2);
1168          assertEquals(2, lock.getQueueLength());
1169          t1.interrupt();
1170 <        Thread.sleep(SHORT_DELAY_MS);
1170 >        awaitTermination(t1);
1171          assertEquals(1, lock.getQueueLength());
1172          lock.writeLock().unlock();
1173 <        Thread.sleep(SHORT_DELAY_MS);
1173 >        awaitTermination(t2);
1174          assertEquals(0, lock.getQueueLength());
1094        t1.join();
1095        t2.join();
1175      }
1176  
1177      /**
1178       * getQueuedThreads includes waiting threads
1179       */
1180      public void testGetQueuedThreads() throws InterruptedException {
1181 <        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1181 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1182          Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1183          Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1184          assertTrue(lock.getQueuedThreads().isEmpty());
1185          lock.writeLock().lock();
1186 +        long startTime = System.nanoTime();
1187          assertTrue(lock.getQueuedThreads().isEmpty());
1188          t1.start();
1189 <        Thread.sleep(SHORT_DELAY_MS);
1189 >        waitForQueuedThread(lock, t1);
1190 >        assertEquals(1, lock.getQueuedThreads().size());
1191          assertTrue(lock.getQueuedThreads().contains(t1));
1192          t2.start();
1193 <        Thread.sleep(SHORT_DELAY_MS);
1193 >        waitForQueuedThread(lock, t2);
1194 >        assertEquals(2, lock.getQueuedThreads().size());
1195          assertTrue(lock.getQueuedThreads().contains(t1));
1196          assertTrue(lock.getQueuedThreads().contains(t2));
1197          t1.interrupt();
1198 <        Thread.sleep(SHORT_DELAY_MS);
1198 >        awaitTermination(t1);
1199          assertFalse(lock.getQueuedThreads().contains(t1));
1200          assertTrue(lock.getQueuedThreads().contains(t2));
1201 +        assertEquals(1, lock.getQueuedThreads().size());
1202          lock.writeLock().unlock();
1203 <        Thread.sleep(SHORT_DELAY_MS);
1203 >        awaitTermination(t2);
1204          assertTrue(lock.getQueuedThreads().isEmpty());
1122        t1.join();
1123        t2.join();
1205      }
1206  
1207      /**
1208       * hasWaiters throws NPE if null
1209       */
1210      public void testHasWaitersNPE() {
1211 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1211 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1212          try {
1213              lock.hasWaiters(null);
1214              shouldThrow();
# Line 1138 | Line 1219 | public class ReentrantReadWriteLockTest
1219       * getWaitQueueLength throws NPE if null
1220       */
1221      public void testGetWaitQueueLengthNPE() {
1222 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1222 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1223          try {
1224              lock.getWaitQueueLength(null);
1225              shouldThrow();
1226          } catch (NullPointerException success) {}
1227      }
1228  
1148
1229      /**
1230       * getWaitingThreads throws NPE if null
1231       */
1232      public void testGetWaitingThreadsNPE() {
1233 <        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1233 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1234          try {
1235              lock.getWaitingThreads(null);
1236              shouldThrow();
# Line 1161 | Line 1241 | public class ReentrantReadWriteLockTest
1241       * hasWaiters throws IAE if not owned
1242       */
1243      public void testHasWaitersIAE() {
1244 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1244 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1245          final Condition c = lock.writeLock().newCondition();
1246 <        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1246 >        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1247          try {
1248              lock2.hasWaiters(c);
1249              shouldThrow();
# Line 1174 | Line 1254 | public class ReentrantReadWriteLockTest
1254       * hasWaiters throws IMSE if not locked
1255       */
1256      public void testHasWaitersIMSE() {
1257 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1257 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1258          final Condition c = lock.writeLock().newCondition();
1259          try {
1260              lock.hasWaiters(c);
# Line 1182 | Line 1262 | public class ReentrantReadWriteLockTest
1262          } catch (IllegalMonitorStateException success) {}
1263      }
1264  
1185
1265      /**
1266       * getWaitQueueLength throws IAE if not owned
1267       */
1268      public void testGetWaitQueueLengthIAE() {
1269 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1269 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1270          final Condition c = lock.writeLock().newCondition();
1271 <        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1271 >        final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1272          try {
1273              lock2.getWaitQueueLength(c);
1274              shouldThrow();
# Line 1200 | Line 1279 | public class ReentrantReadWriteLockTest
1279       * getWaitQueueLength throws IMSE if not locked
1280       */
1281      public void testGetWaitQueueLengthIMSE() {
1282 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1282 >        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1283          final Condition c = lock.writeLock().newCondition();
1284          try {
1285              lock.getWaitQueueLength(c);
# Line 1208 | Line 1287 | public class ReentrantReadWriteLockTest
1287          } catch (IllegalMonitorStateException success) {}
1288      }
1289  
1211
1290      /**
1291       * getWaitingThreads throws IAE if not owned
1292       */
1293      public void testGetWaitingThreadsIAE() {
1294 <        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1294 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1295          final Condition c = lock.writeLock().newCondition();
1296 <        final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1296 >        final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1297          try {
1298              lock2.getWaitingThreads(c);
1299              shouldThrow();
# Line 1226 | Line 1304 | public class ReentrantReadWriteLockTest
1304       * getWaitingThreads throws IMSE if not locked
1305       */
1306      public void testGetWaitingThreadsIMSE() {
1307 <        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1307 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1308          final Condition c = lock.writeLock().newCondition();
1309          try {
1310              lock.getWaitingThreads(c);
# Line 1234 | Line 1312 | public class ReentrantReadWriteLockTest
1312          } catch (IllegalMonitorStateException success) {}
1313      }
1314  
1237
1315      /**
1316       * hasWaiters returns true when a thread is waiting, else false
1317       */
1318      public void testHasWaiters() throws InterruptedException {
1319 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1319 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1320          final Condition c = lock.writeLock().newCondition();
1321 <        Thread t = new Thread(new CheckedRunnable() {
1321 >        final CountDownLatch locked = new CountDownLatch(1);
1322 >        Thread t = newStartedThread(new CheckedRunnable() {
1323              public void realRun() throws InterruptedException {
1324                  lock.writeLock().lock();
1325 <                threadAssertFalse(lock.hasWaiters(c));
1326 <                threadAssertEquals(0, lock.getWaitQueueLength(c));
1325 >                assertFalse(lock.hasWaiters(c));
1326 >                locked.countDown();
1327 >                assertEquals(0, lock.getWaitQueueLength(c));
1328                  c.await();
1329                  lock.writeLock().unlock();
1330              }});
1331  
1332 <        t.start();
1254 <        Thread.sleep(SHORT_DELAY_MS);
1332 >        locked.await();
1333          lock.writeLock().lock();
1334          assertTrue(lock.hasWaiters(c));
1335          assertEquals(1, lock.getWaitQueueLength(c));
1336          c.signal();
1337 +        assertHasNoWaiters(lock, c);
1338          lock.writeLock().unlock();
1339 <        Thread.sleep(SHORT_DELAY_MS);
1340 <        lock.writeLock().lock();
1262 <        assertFalse(lock.hasWaiters(c));
1263 <        assertEquals(0, lock.getWaitQueueLength(c));
1264 <        lock.writeLock().unlock();
1265 <        t.join(SHORT_DELAY_MS);
1266 <        assertFalse(t.isAlive());
1339 >        awaitTermination(t);
1340 >        assertHasNoWaiters(lock, c);
1341      }
1342  
1343      /**
1344       * getWaitQueueLength returns number of waiting threads
1345       */
1346      public void testGetWaitQueueLength() throws InterruptedException {
1347 <        final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1347 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1348          final Condition c = lock.writeLock().newCondition();
1349 <        Thread t = new Thread(new CheckedRunnable() {
1349 >        final CountDownLatch locked = new CountDownLatch(1);
1350 >        Thread t = newStartedThread(new CheckedRunnable() {
1351              public void realRun() throws InterruptedException {
1352                  lock.writeLock().lock();
1353 <                threadAssertFalse(lock.hasWaiters(c));
1354 <                threadAssertEquals(0, lock.getWaitQueueLength(c));
1353 >                assertEquals(0, lock.getWaitQueueLength(c));
1354 >                locked.countDown();
1355                  c.await();
1356                  lock.writeLock().unlock();
1357              }});
1358  
1359 <        t.start();
1285 <        Thread.sleep(SHORT_DELAY_MS);
1359 >        locked.await();
1360          lock.writeLock().lock();
1361 <        assertTrue(lock.hasWaiters(c));
1361 >        assertHasWaiters(lock, c, t);
1362          assertEquals(1, lock.getWaitQueueLength(c));
1363          c.signal();
1364 <        lock.writeLock().unlock();
1291 <        Thread.sleep(SHORT_DELAY_MS);
1292 <        lock.writeLock().lock();
1293 <        assertFalse(lock.hasWaiters(c));
1364 >        assertHasNoWaiters(lock, c);
1365          assertEquals(0, lock.getWaitQueueLength(c));
1366          lock.writeLock().unlock();
1367 <        t.join(SHORT_DELAY_MS);
1297 <        assertFalse(t.isAlive());
1367 >        awaitTermination(t);
1368      }
1369  
1300
1370      /**
1371       * getWaitingThreads returns only and all waiting threads
1372       */
1373      public void testGetWaitingThreads() throws InterruptedException {
1374 <        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1374 >        final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1375          final Condition c = lock.writeLock().newCondition();
1376 <        Thread t1 = new Thread(new CheckedRunnable() {
1376 >        final CountDownLatch locked1 = new CountDownLatch(1);
1377 >        final CountDownLatch locked2 = new CountDownLatch(1);
1378 >        Thread t1 = new Thread(new CheckedRunnable() {
1379              public void realRun() throws InterruptedException {
1380                  lock.writeLock().lock();
1381 <                threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
1381 >                assertTrue(lock.getWaitingThreads(c).isEmpty());
1382 >                locked1.countDown();
1383                  c.await();
1384                  lock.writeLock().unlock();
1385              }});
1386  
1387 <        Thread t2 = new Thread(new CheckedRunnable() {
1387 >        Thread t2 = new Thread(new CheckedRunnable() {
1388              public void realRun() throws InterruptedException {
1389                  lock.writeLock().lock();
1390 <                threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
1390 >                assertFalse(lock.getWaitingThreads(c).isEmpty());
1391 >                locked2.countDown();
1392                  c.await();
1393                  lock.writeLock().unlock();
1394              }});
# Line 1323 | Line 1396 | public class ReentrantReadWriteLockTest
1396          lock.writeLock().lock();
1397          assertTrue(lock.getWaitingThreads(c).isEmpty());
1398          lock.writeLock().unlock();
1399 +
1400          t1.start();
1401 <        Thread.sleep(SHORT_DELAY_MS);
1401 >        locked1.await();
1402          t2.start();
1403 <        Thread.sleep(SHORT_DELAY_MS);
1403 >        locked2.await();
1404 >
1405          lock.writeLock().lock();
1406          assertTrue(lock.hasWaiters(c));
1407          assertTrue(lock.getWaitingThreads(c).contains(t1));
1408          assertTrue(lock.getWaitingThreads(c).contains(t2));
1409 +        assertEquals(2, lock.getWaitingThreads(c).size());
1410          c.signalAll();
1411 +        assertHasNoWaiters(lock, c);
1412          lock.writeLock().unlock();
1413 <        Thread.sleep(SHORT_DELAY_MS);
1414 <        lock.writeLock().lock();
1415 <        assertFalse(lock.hasWaiters(c));
1416 <        assertTrue(lock.getWaitingThreads(c).isEmpty());
1417 <        lock.writeLock().unlock();
1341 <        t1.join(SHORT_DELAY_MS);
1342 <        t2.join(SHORT_DELAY_MS);
1343 <        assertFalse(t1.isAlive());
1344 <        assertFalse(t2.isAlive());
1413 >
1414 >        awaitTermination(t1);
1415 >        awaitTermination(t2);
1416 >
1417 >        assertHasNoWaiters(lock, c);
1418      }
1419  
1420      /**

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines