ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.38 by jsr166, Sat Nov 21 21:59:50 2009 UTC vs.
Revision 1.54 by jsr166, Mon May 2 01:07:15 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		*/
#	Line 15 | Line 15 | import java.util.*;
15
16		public class ReentrantReadWriteLockTest extends JSR166TestCase {
17		public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
18	>	junit.textui.TestRunner.run(suite());
19		}
20		public static Test suite() {
21		return new TestSuite(ReentrantReadWriteLockTest.class);
#	Line 59 | 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		* Constructor sets given fairness, and is in unlocked state
73		*/
74		public void testConstructor() {
#	Line 190 | Line 200 | public class ReentrantReadWriteLockTest
200		*/
201		public void testWriteLockInterruptibly_Interrupted() throws Exception {
202		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
203	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
203	>	lock.writeLock().lock();
204	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
205		public void realRun() throws InterruptedException {
206		lock.writeLock().lockInterruptibly();
196	–	lock.writeLock().unlock();
197	–	lock.writeLock().lockInterruptibly();
198	–	lock.writeLock().unlock();
207		}});
208
201	–	lock.writeLock().lock();
202	–	t.start();
209		Thread.sleep(SHORT_DELAY_MS);
210		t.interrupt();
211	<	Thread.sleep(SHORT_DELAY_MS);
212	<	lock.writeLock().unlock();
207	<	t.join();
211	>	awaitTermination(t, LONG_DELAY_MS);
212	>	releaseWriteLock(lock);
213		}
214
215		/**
#	Line 213 | Line 218 | public class ReentrantReadWriteLockTest
218		public void testWriteTryLock_Interrupted() throws InterruptedException {
219		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
220		lock.writeLock().lock();
221	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
221	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
222		public void realRun() throws InterruptedException {
223		lock.writeLock().tryLock(SMALL_DELAY_MS, MILLISECONDS);
224		}});
225
221	–	t.start();
226		Thread.sleep(SHORT_DELAY_MS);
227		t.interrupt();
228	<	lock.writeLock().unlock();
229	<	t.join();
228	>	awaitTermination(t, LONG_DELAY_MS);
229	>	releaseWriteLock(lock);
230		}
231
232		/**
#	Line 231 | Line 235 | public class ReentrantReadWriteLockTest
235		public void testReadLockInterruptibly_Interrupted() throws InterruptedException {
236		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
237		lock.writeLock().lock();
238	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
238	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
239		public void realRun() throws InterruptedException {
240		lock.readLock().lockInterruptibly();
241		}});
242
239	–	t.start();
243		Thread.sleep(SHORT_DELAY_MS);
244		t.interrupt();
245	<	Thread.sleep(SHORT_DELAY_MS);
246	<	lock.writeLock().unlock();
244	<	t.join();
245	>	awaitTermination(t, LONG_DELAY_MS);
246	>	releaseWriteLock(lock);
247		}
248
249		/**
#	Line 250 | Line 252 | public class ReentrantReadWriteLockTest
252		public void testReadTryLock_Interrupted() throws InterruptedException {
253		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
254		lock.writeLock().lock();
255	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
255	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
256		public void realRun() throws InterruptedException {
257	<	lock.readLock().tryLock(1000,MILLISECONDS);
257	>	lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS);
258		}});
259
260	<	t.start();
260	>	Thread.sleep(SHORT_DELAY_MS);
261		t.interrupt();
262	<	t.join();
262	>	awaitTermination(t, LONG_DELAY_MS);
263	>	releaseWriteLock(lock);
264		}
265
266
#	Line 267 | Line 270 | public class ReentrantReadWriteLockTest
270		public void testWriteTryLockWhenLocked() throws InterruptedException {
271		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
272		lock.writeLock().lock();
273	<	Thread t = new Thread(new CheckedRunnable() {
273	>	Thread t = newStartedThread(new CheckedRunnable() {
274		public void realRun() {
275	<	threadAssertFalse(lock.writeLock().tryLock());
275	>	assertFalse(lock.writeLock().tryLock());
276		}});
277
278	<	t.start();
279	<	t.join();
277	<	lock.writeLock().unlock();
278	>	awaitTermination(t, LONG_DELAY_MS);
279	>	releaseWriteLock(lock);
280		}
281
282		/**
#	Line 283 | Line 285 | public class ReentrantReadWriteLockTest
285		public void testReadTryLockWhenLocked() throws InterruptedException {
286		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
287		lock.writeLock().lock();
288	<	Thread t = new Thread(new CheckedRunnable() {
288	>	Thread t = newStartedThread(new CheckedRunnable() {
289		public void realRun() {
290	<	threadAssertFalse(lock.readLock().tryLock());
290	>	assertFalse(lock.readLock().tryLock());
291		}});
292
293	<	t.start();
294	<	t.join();
293	<	lock.writeLock().unlock();
293	>	awaitTermination(t, LONG_DELAY_MS);
294	>	releaseWriteLock(lock);
295		}
296
297		/**
#	Line 299 | Line 300 | public class ReentrantReadWriteLockTest
300		public void testMultipleReadLocks() throws InterruptedException {
301		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
302		lock.readLock().lock();
303	<	Thread t = new Thread(new CheckedRunnable() {
303	>	Thread t = newStartedThread(new CheckedRunnable() {
304		public void realRun() {
305	<	threadAssertTrue(lock.readLock().tryLock());
305	>	assertTrue(lock.readLock().tryLock());
306		lock.readLock().unlock();
307		}});
308
309	<	t.start();
309	<	t.join();
309	>	awaitTermination(t, LONG_DELAY_MS);
310		lock.readLock().unlock();
311		}
312
#	Line 316 | Line 316 | public class ReentrantReadWriteLockTest
316		public void testWriteAfterMultipleReadLocks() throws InterruptedException {
317		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
318		lock.readLock().lock();
319	<	Thread t1 = new Thread(new CheckedRunnable() {
319	>	Thread t1 = newStartedThread(new CheckedRunnable() {
320		public void realRun() {
321		lock.readLock().lock();
322		lock.readLock().unlock();
323		}});
324	<	Thread t2 = new Thread(new CheckedRunnable() {
324	>	Thread t2 = newStartedThread(new CheckedRunnable() {
325		public void realRun() {
326		lock.writeLock().lock();
327		lock.writeLock().unlock();
328		}});
329
330	–	t1.start();
331	–	t2.start();
330		Thread.sleep(SHORT_DELAY_MS);
331		lock.readLock().unlock();
332	<	t1.join(MEDIUM_DELAY_MS);
333	<	t2.join(MEDIUM_DELAY_MS);
336	<	assertTrue(!t1.isAlive());
337	<	assertTrue(!t2.isAlive());
332	>	awaitTermination(t1, LONG_DELAY_MS);
333	>	awaitTermination(t2, LONG_DELAY_MS);
334		}
335
336		/**
#	Line 343 | Line 339 | public class ReentrantReadWriteLockTest
339		public void testReadAfterWriteLock() throws InterruptedException {
340		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
341		lock.writeLock().lock();
342	<	Thread t1 = new Thread(new CheckedRunnable() {
342	>	Thread t1 = newStartedThread(new CheckedRunnable() {
343		public void realRun() {
344		lock.readLock().lock();
345		lock.readLock().unlock();
346		}});
347	<	Thread t2 = new Thread(new CheckedRunnable() {
347	>	Thread t2 = newStartedThread(new CheckedRunnable() {
348		public void realRun() {
349		lock.readLock().lock();
350		lock.readLock().unlock();
351		}});
352
357	–	t1.start();
358	–	t2.start();
353		Thread.sleep(SHORT_DELAY_MS);
354	<	lock.writeLock().unlock();
355	<	t1.join(MEDIUM_DELAY_MS);
356	<	t2.join(MEDIUM_DELAY_MS);
363	<	assertTrue(!t1.isAlive());
364	<	assertTrue(!t2.isAlive());
354	>	releaseWriteLock(lock);
355	>	awaitTermination(t1, LONG_DELAY_MS);
356	>	awaitTermination(t2, LONG_DELAY_MS);
357		}
358
359		/**
#	Line 382 | Line 374 | public class ReentrantReadWriteLockTest
374		public void testReadHoldingWriteLock2() throws InterruptedException {
375		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
376		lock.writeLock().lock();
377	<	Thread t1 = new Thread(new CheckedRunnable() {
377	>	Thread t1 = newStartedThread(new CheckedRunnable() {
378		public void realRun() {
379		lock.readLock().lock();
380		lock.readLock().unlock();
381		}});
382	<	Thread t2 = new Thread(new CheckedRunnable() {
382	>	Thread t2 = newStartedThread(new CheckedRunnable() {
383		public void realRun() {
384		lock.readLock().lock();
385		lock.readLock().unlock();
386		}});
387
396	–	t1.start();
397	–	t2.start();
388		lock.readLock().lock();
389		lock.readLock().unlock();
390		Thread.sleep(SHORT_DELAY_MS);
391		lock.readLock().lock();
392		lock.readLock().unlock();
393		lock.writeLock().unlock();
394	<	t1.join(MEDIUM_DELAY_MS);
395	<	t2.join(MEDIUM_DELAY_MS);
406	<	assertTrue(!t1.isAlive());
407	<	assertTrue(!t2.isAlive());
394	>	awaitTermination(t1, LONG_DELAY_MS);
395	>	awaitTermination(t2, LONG_DELAY_MS);
396		}
397
398		/**
399	<	*  Read lock succeeds if write locked by current thread even if
399	>	* Read lock succeeds if write locked by current thread even if
400		* other threads are waiting for writelock
401		*/
402		public void testReadHoldingWriteLock3() throws InterruptedException {
403		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
404		lock.writeLock().lock();
405	<	Thread t1 = new Thread(new CheckedRunnable() {
405	>	Thread t1 = newStartedThread(new CheckedRunnable() {
406		public void realRun() {
407		lock.writeLock().lock();
408		lock.writeLock().unlock();
409		}});
410	<	Thread t2 = new Thread(new CheckedRunnable() {
410	>	Thread t2 = newStartedThread(new CheckedRunnable() {
411		public void realRun() {
412		lock.writeLock().lock();
413		lock.writeLock().unlock();
414		}});
415
428	–	t1.start();
429	–	t2.start();
416		lock.readLock().lock();
417		lock.readLock().unlock();
418		Thread.sleep(SHORT_DELAY_MS);
419		lock.readLock().lock();
420		lock.readLock().unlock();
421		lock.writeLock().unlock();
422	<	t1.join(MEDIUM_DELAY_MS);
423	<	t2.join(MEDIUM_DELAY_MS);
438	<	assertTrue(!t1.isAlive());
439	<	assertTrue(!t2.isAlive());
422	>	awaitTermination(t1, LONG_DELAY_MS);
423	>	awaitTermination(t2, LONG_DELAY_MS);
424		}
425
426
427		/**
428	<	*  Write lock succeeds if write locked by current thread even if
428	>	* Write lock succeeds if write locked by current thread even if
429		* other threads are waiting for writelock
430		*/
431		public void testWriteHoldingWriteLock4() throws InterruptedException {
432		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
433		lock.writeLock().lock();
434	<	Thread t1 = new Thread(new CheckedRunnable() {
434	>	Thread t1 = newStartedThread(new CheckedRunnable() {
435		public void realRun() {
436		lock.writeLock().lock();
437		lock.writeLock().unlock();
438		}});
439	<	Thread t2 = new Thread(new CheckedRunnable() {
439	>	Thread t2 = newStartedThread(new CheckedRunnable() {
440		public void realRun() {
441		lock.writeLock().lock();
442		lock.writeLock().unlock();
443		}});
444
461	–	t1.start();
462	–	t2.start();
445		lock.writeLock().lock();
446		lock.writeLock().unlock();
447		Thread.sleep(SHORT_DELAY_MS);
448		lock.writeLock().lock();
449		lock.writeLock().unlock();
450		lock.writeLock().unlock();
451	<	t1.join(MEDIUM_DELAY_MS);
452	<	t2.join(MEDIUM_DELAY_MS);
471	<	assertTrue(!t1.isAlive());
472	<	assertTrue(!t2.isAlive());
451	>	awaitTermination(t1, LONG_DELAY_MS);
452	>	awaitTermination(t2, LONG_DELAY_MS);
453		}
454
455
#	Line 491 | Line 471 | public class ReentrantReadWriteLockTest
471		public void testReadHoldingWriteLockFair2() throws InterruptedException {
472		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
473		lock.writeLock().lock();
474	<	Thread t1 = new Thread(new CheckedRunnable() {
474	>	Thread t1 = newStartedThread(new CheckedRunnable() {
475		public void realRun() {
476		lock.readLock().lock();
477		lock.readLock().unlock();
478		}});
479	<	Thread t2 = new Thread(new CheckedRunnable() {
479	>	Thread t2 = newStartedThread(new CheckedRunnable() {
480		public void realRun() {
481		lock.readLock().lock();
482		lock.readLock().unlock();
483		}});
484
505	–	t1.start();
506	–	t2.start();
485		lock.readLock().lock();
486		lock.readLock().unlock();
487		Thread.sleep(SHORT_DELAY_MS);
488		lock.readLock().lock();
489		lock.readLock().unlock();
490		lock.writeLock().unlock();
491	<	t1.join(MEDIUM_DELAY_MS);
492	<	t2.join(MEDIUM_DELAY_MS);
515	<	assertTrue(!t1.isAlive());
516	<	assertTrue(!t2.isAlive());
491	>	awaitTermination(t1, LONG_DELAY_MS);
492	>	awaitTermination(t2, LONG_DELAY_MS);
493		}
494
495
#	Line 524 | Line 500 | public class ReentrantReadWriteLockTest
500		public void testReadHoldingWriteLockFair3() throws InterruptedException {
501		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
502		lock.writeLock().lock();
503	<	Thread t1 = new Thread(new CheckedRunnable() {
503	>	Thread t1 = newStartedThread(new CheckedRunnable() {
504		public void realRun() {
505		lock.writeLock().lock();
506		lock.writeLock().unlock();
507		}});
508	<	Thread t2 = new Thread(new CheckedRunnable() {
508	>	Thread t2 = newStartedThread(new CheckedRunnable() {
509		public void realRun() {
510		lock.writeLock().lock();
511		lock.writeLock().unlock();
512		}});
513
538	–	t1.start();
539	–	t2.start();
514		lock.readLock().lock();
515		lock.readLock().unlock();
516		Thread.sleep(SHORT_DELAY_MS);
517		lock.readLock().lock();
518		lock.readLock().unlock();
519		lock.writeLock().unlock();
520	<	t1.join(MEDIUM_DELAY_MS);
521	<	t2.join(MEDIUM_DELAY_MS);
548	<	assertTrue(!t1.isAlive());
549	<	assertTrue(!t2.isAlive());
520	>	awaitTermination(t1, LONG_DELAY_MS);
521	>	awaitTermination(t2, LONG_DELAY_MS);
522		}
523
524
#	Line 557 | Line 529 | public class ReentrantReadWriteLockTest
529		public void testWriteHoldingWriteLockFair4() throws InterruptedException {
530		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
531		lock.writeLock().lock();
532	<	Thread t1 = new Thread(new CheckedRunnable() {
532	>	Thread t1 = newStartedThread(new CheckedRunnable() {
533		public void realRun() {
534		lock.writeLock().lock();
535		lock.writeLock().unlock();
536		}});
537	<	Thread t2 = new Thread(new CheckedRunnable() {
537	>	Thread t2 = newStartedThread(new CheckedRunnable() {
538		public void realRun() {
539		lock.writeLock().lock();
540		lock.writeLock().unlock();
541		}});
542
571	–	t1.start();
572	–	t2.start();
543		Thread.sleep(SHORT_DELAY_MS);
544		assertTrue(lock.isWriteLockedByCurrentThread());
545	<	assertTrue(lock.getWriteHoldCount() == 1);
545	>	assertEquals(1, lock.getWriteHoldCount());
546		lock.writeLock().lock();
547	<	assertTrue(lock.getWriteHoldCount() == 2);
547	>	assertEquals(2, lock.getWriteHoldCount());
548		lock.writeLock().unlock();
549		lock.writeLock().lock();
550		lock.writeLock().unlock();
551		lock.writeLock().unlock();
552	<	t1.join(MEDIUM_DELAY_MS);
553	<	t2.join(MEDIUM_DELAY_MS);
584	<	assertTrue(!t1.isAlive());
585	<	assertTrue(!t2.isAlive());
552	>	awaitTermination(t1, LONG_DELAY_MS);
553	>	awaitTermination(t2, LONG_DELAY_MS);
554		}
555
556
#	Line 592 | Line 560 | public class ReentrantReadWriteLockTest
560		public void testTryLockWhenReadLocked() throws InterruptedException {
561		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
562		lock.readLock().lock();
563	<	Thread t = new Thread(new CheckedRunnable() {
563	>	Thread t = newStartedThread(new CheckedRunnable() {
564		public void realRun() {
565	<	threadAssertTrue(lock.readLock().tryLock());
565	>	assertTrue(lock.readLock().tryLock());
566		lock.readLock().unlock();
567		}});
568
569	<	t.start();
602	<	t.join();
569	>	awaitTermination(t, LONG_DELAY_MS);
570		lock.readLock().unlock();
571		}
572
606	–
607	–
573		/**
574		* write tryLock fails when readlocked
575		*/
576		public void testWriteTryLockWhenReadLocked() throws InterruptedException {
577		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
578		lock.readLock().lock();
579	<	Thread t = new Thread(new CheckedRunnable() {
579	>	Thread t = newStartedThread(new CheckedRunnable() {
580		public void realRun() {
581	<	threadAssertFalse(lock.writeLock().tryLock());
581	>	assertFalse(lock.writeLock().tryLock());
582		}});
583
584	<	t.start();
620	<	t.join();
584	>	awaitTermination(t, LONG_DELAY_MS);
585		lock.readLock().unlock();
586		}
587
#	Line 628 | Line 592 | public class ReentrantReadWriteLockTest
592		public void testTryLockWhenReadLockedFair() throws InterruptedException {
593		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
594		lock.readLock().lock();
595	<	Thread t = new Thread(new CheckedRunnable() {
595	>	Thread t = newStartedThread(new CheckedRunnable() {
596		public void realRun() {
597	<	threadAssertTrue(lock.readLock().tryLock());
597	>	assertTrue(lock.readLock().tryLock());
598		lock.readLock().unlock();
599		}});
600
601	<	t.start();
638	<	t.join();
601	>	awaitTermination(t, LONG_DELAY_MS);
602		lock.readLock().unlock();
603		}
604
#	Line 647 | Line 610 | public class ReentrantReadWriteLockTest
610		public void testWriteTryLockWhenReadLockedFair() throws InterruptedException {
611		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
612		lock.readLock().lock();
613	<	Thread t = new Thread(new CheckedRunnable() {
613	>	Thread t = newStartedThread(new CheckedRunnable() {
614		public void realRun() {
615	<	threadAssertFalse(lock.writeLock().tryLock());
615	>	assertFalse(lock.writeLock().tryLock());
616		}});
617
618	<	t.start();
656	<	t.join();
618	>	awaitTermination(t, LONG_DELAY_MS);
619		lock.readLock().unlock();
620		}
621
#	Line 665 | Line 627 | public class ReentrantReadWriteLockTest
627		public void testWriteTryLock_Timeout() throws InterruptedException {
628		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
629		lock.writeLock().lock();
630	<	Thread t = new Thread(new CheckedRunnable() {
630	>	Thread t = newStartedThread(new CheckedRunnable() {
631		public void realRun() throws InterruptedException {
632	<	threadAssertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
632	>	assertFalse(lock.writeLock().tryLock(1, MILLISECONDS));
633		}});
634
635	<	t.start();
674	<	t.join();
635	>	awaitTermination(t, LONG_DELAY_MS);
636		assertTrue(lock.writeLock().isHeldByCurrentThread());
637		lock.writeLock().unlock();
638		}
#	Line 682 | Line 643 | public class ReentrantReadWriteLockTest
643		public void testReadTryLock_Timeout() throws InterruptedException {
644		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
645		lock.writeLock().lock();
646	<	Thread t = new Thread(new CheckedRunnable() {
646	>	Thread t = newStartedThread(new CheckedRunnable() {
647		public void realRun() throws InterruptedException {
648	<	threadAssertFalse(lock.readLock().tryLock(1, MILLISECONDS));
648	>	assertFalse(lock.readLock().tryLock(1, MILLISECONDS));
649		}});
650
651	<	t.start();
691	<	t.join();
651	>	awaitTermination(t, LONG_DELAY_MS);
652		assertTrue(lock.writeLock().isHeldByCurrentThread());
653		lock.writeLock().unlock();
654		}
#	Line 700 | Line 660 | public class ReentrantReadWriteLockTest
660		public void testWriteLockInterruptibly() throws InterruptedException {
661		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
662		lock.writeLock().lockInterruptibly();
663	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
663	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
664		public void realRun() throws InterruptedException {
665		lock.writeLock().lockInterruptibly();
666		}});
667
708	–	t.start();
668		Thread.sleep(SHORT_DELAY_MS);
669		t.interrupt();
670	<	Thread.sleep(SHORT_DELAY_MS);
671	<	t.join();
713	<	lock.writeLock().unlock();
670	>	awaitTermination(t, LONG_DELAY_MS);
671	>	releaseWriteLock(lock);
672		}
673
674		/**
675	<	*  read lockInterruptibly succeeds if lock free else is interruptible
675	>	* read lockInterruptibly succeeds if lock free else is interruptible
676		*/
677		public void testReadLockInterruptibly() throws InterruptedException {
678		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
679		lock.writeLock().lockInterruptibly();
680	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
680	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
681		public void realRun() throws InterruptedException {
682		lock.readLock().lockInterruptibly();
683		}});
684
727	–	t.start();
685		Thread.sleep(SHORT_DELAY_MS);
686		t.interrupt();
687	<	t.join();
688	<	lock.writeLock().unlock();
687	>	awaitTermination(t, LONG_DELAY_MS);
688	>	releaseWriteLock(lock);
689		}
690
691		/**
#	Line 770 | Line 727 | public class ReentrantReadWriteLockTest
727
728
729		/**
730	<	*  timed await without a signal times out
730	>	* timed await without a signal times out
731		*/
732		public void testAwait_Timeout() throws InterruptedException {
733		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
#	Line 798 | Line 755 | public class ReentrantReadWriteLockTest
755		public void testAwait() throws InterruptedException {
756		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
757		final Condition c = lock.writeLock().newCondition();
758	<	Thread t = new Thread(new CheckedRunnable() {
758	>	Thread t = newStartedThread(new CheckedRunnable() {
759		public void realRun() throws InterruptedException {
760		lock.writeLock().lock();
761		c.await();
762		lock.writeLock().unlock();
763		}});
764
808	–	t.start();
765		Thread.sleep(SHORT_DELAY_MS);
766		lock.writeLock().lock();
767		c.signal();
768		lock.writeLock().unlock();
769	<	t.join(SHORT_DELAY_MS);
814	<	assertFalse(t.isAlive());
769	>	awaitTermination(t, LONG_DELAY_MS);
770		}
771
772		/** A helper class for uninterruptible wait tests */
#	Line 864 | Line 819 | public class ReentrantReadWriteLockTest
819		lock.writeLock().unlock();
820		}
821
822	<	thread.join();
822	>	awaitTermination(thread, LONG_DELAY_MS);
823		assertTrue(thread.interrupted);
869	–	assertFalse(thread.isAlive());
824		}
825
826		/**
#	Line 875 | Line 829 | public class ReentrantReadWriteLockTest
829		public void testAwait_Interrupt() throws InterruptedException {
830		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
831		final Condition c = lock.writeLock().newCondition();
832	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
832	>	final CountDownLatch locked = new CountDownLatch(1);
833	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
834		public void realRun() throws InterruptedException {
835		lock.writeLock().lock();
836	<	c.await();
837	<	lock.writeLock().unlock();
836	>	assertTrue(lock.isWriteLocked());
837	>	locked.countDown();
838	>	try { c.await(); }
839	>	finally { lock.writeLock().unlock(); }
840		}});
841
842	<	t.start();
843	<	Thread.sleep(SHORT_DELAY_MS);
842	>	locked.await();
843	>	while (lock.isWriteLocked())
844	>	Thread.yield();
845		t.interrupt();
846	<	t.join(SHORT_DELAY_MS);
847	<	assertFalse(t.isAlive());
846	>	awaitTermination(t, LONG_DELAY_MS);
847	>	assertFalse(lock.isWriteLocked());
848		}
849
850		/**
#	Line 895 | Line 853 | public class ReentrantReadWriteLockTest
853		public void testAwaitNanos_Interrupt() throws InterruptedException {
854		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
855		final Condition c = lock.writeLock().newCondition();
856	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
856	>	final CountDownLatch locked = new CountDownLatch(1);
857	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
858		public void realRun() throws InterruptedException {
859		lock.writeLock().lock();
860	<	c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
861	<	lock.writeLock().unlock();
860	>	assertTrue(lock.isWriteLocked());
861	>	locked.countDown();
862	>	try { c.awaitNanos(MILLISECONDS.toNanos(LONG_DELAY_MS)); }
863	>	finally { lock.writeLock().unlock(); }
864		}});
865
866	<	t.start();
867	<	Thread.sleep(SHORT_DELAY_MS);
866	>	locked.await();
867	>	while (lock.isWriteLocked())
868	>	Thread.yield();
869		t.interrupt();
870	<	t.join(SHORT_DELAY_MS);
871	<	assertFalse(t.isAlive());
870	>	awaitTermination(t, LONG_DELAY_MS);
871	>	assertFalse(lock.isWriteLocked());
872		}
873
874		/**
#	Line 915 | Line 877 | public class ReentrantReadWriteLockTest
877		public void testAwaitUntil_Interrupt() throws InterruptedException {
878		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
879		final Condition c = lock.writeLock().newCondition();
880	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
880	>	final CountDownLatch locked = new CountDownLatch(1);
881	>	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
882		public void realRun() throws InterruptedException {
883		lock.writeLock().lock();
884	+	assertTrue(lock.isWriteLocked());
885	+	locked.countDown();
886		java.util.Date d = new java.util.Date();
887	<	c.awaitUntil(new java.util.Date(d.getTime() + 10000));
888	<	lock.writeLock().unlock();
887	>	try { c.awaitUntil(new java.util.Date(d.getTime() + 10000)); }
888	>	finally { lock.writeLock().unlock(); }
889		}});
890
891	<	t.start();
892	<	Thread.sleep(SHORT_DELAY_MS);
891	>	locked.await();
892	>	while (lock.isWriteLocked())
893	>	Thread.yield();
894		t.interrupt();
895	<	t.join(SHORT_DELAY_MS);
896	<	assertFalse(t.isAlive());
895	>	awaitTermination(t, LONG_DELAY_MS);
896	>	assertFalse(lock.isWriteLocked());
897		}
898
899		/**
#	Line 936 | Line 902 | public class ReentrantReadWriteLockTest
902		public void testSignalAll() throws InterruptedException {
903		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
904		final Condition c = lock.writeLock().newCondition();
905	<	Thread t1 = new Thread(new CheckedRunnable() {
905	>	Thread t1 = newStartedThread(new CheckedRunnable() {
906		public void realRun() throws InterruptedException {
907		lock.writeLock().lock();
908		c.await();
909		lock.writeLock().unlock();
910		}});
911
912	<	Thread t2 = new Thread(new CheckedRunnable() {
912	>	Thread t2 = newStartedThread(new CheckedRunnable() {
913		public void realRun() throws InterruptedException {
914		lock.writeLock().lock();
915		c.await();
916		lock.writeLock().unlock();
917		}});
918
953	–	t1.start();
954	–	t2.start();
919		Thread.sleep(SHORT_DELAY_MS);
920		lock.writeLock().lock();
921		c.signalAll();
922		lock.writeLock().unlock();
923	<	t1.join(SHORT_DELAY_MS);
924	<	t2.join(SHORT_DELAY_MS);
961	<	assertFalse(t1.isAlive());
962	<	assertFalse(t2.isAlive());
923	>	awaitTermination(t1, LONG_DELAY_MS);
924	>	awaitTermination(t2, LONG_DELAY_MS);
925		}
926
927		/**
#	Line 1003 | Line 965 | public class ReentrantReadWriteLockTest
965		lock.writeLock().unlock();
966		Thread.sleep(SHORT_DELAY_MS);
967		assertFalse(lock.hasQueuedThreads());
968	<	t1.join();
969	<	t2.join();
968	>	awaitTermination(t1, LONG_DELAY_MS);
969	>	awaitTermination(t2, LONG_DELAY_MS);
970		}
971
972		/**
#	Line 1044 | Line 1006 | public class ReentrantReadWriteLockTest
1006		assertFalse(sync.hasQueuedThread(t1));
1007		Thread.sleep(SHORT_DELAY_MS);
1008		assertFalse(sync.hasQueuedThread(t2));
1009	<	t1.join();
1010	<	t2.join();
1009	>	awaitTermination(t1, LONG_DELAY_MS);
1010	>	awaitTermination(t2, LONG_DELAY_MS);
1011		}
1012
1013
#	Line 1070 | Line 1032 | public class ReentrantReadWriteLockTest
1032		lock.writeLock().unlock();
1033		Thread.sleep(SHORT_DELAY_MS);
1034		assertEquals(0, lock.getQueueLength());
1035	<	t1.join();
1036	<	t2.join();
1035	>	awaitTermination(t1, LONG_DELAY_MS);
1036	>	awaitTermination(t2, LONG_DELAY_MS);
1037		}
1038
1039		/**
#	Line 1098 | Line 1060 | public class ReentrantReadWriteLockTest
1060		lock.writeLock().unlock();
1061		Thread.sleep(SHORT_DELAY_MS);
1062		assertTrue(lock.getQueuedThreads().isEmpty());
1063	<	t1.join();
1064	<	t2.join();
1063	>	awaitTermination(t1, LONG_DELAY_MS);
1064	>	awaitTermination(t2, LONG_DELAY_MS);
1065		}
1066
1067		/**
#	Line 1220 | Line 1182 | public class ReentrantReadWriteLockTest
1182		public void testHasWaiters() throws InterruptedException {
1183		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1184		final Condition c = lock.writeLock().newCondition();
1185	<	Thread t = new Thread(new CheckedRunnable() {
1185	>	Thread t = newStartedThread(new CheckedRunnable() {
1186		public void realRun() throws InterruptedException {
1187		lock.writeLock().lock();
1188	<	threadAssertFalse(lock.hasWaiters(c));
1189	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
1188	>	assertFalse(lock.hasWaiters(c));
1189	>	assertEquals(0, lock.getWaitQueueLength(c));
1190		c.await();
1191		lock.writeLock().unlock();
1192		}});
1193
1232	–	t.start();
1194		Thread.sleep(SHORT_DELAY_MS);
1195		lock.writeLock().lock();
1196		assertTrue(lock.hasWaiters(c));
#	Line 1241 | Line 1202 | public class ReentrantReadWriteLockTest
1202		assertFalse(lock.hasWaiters(c));
1203		assertEquals(0, lock.getWaitQueueLength(c));
1204		lock.writeLock().unlock();
1205	<	t.join(SHORT_DELAY_MS);
1245	<	assertFalse(t.isAlive());
1205	>	awaitTermination(t, LONG_DELAY_MS);
1206		}
1207
1208		/**
#	Line 1251 | Line 1211 | public class ReentrantReadWriteLockTest
1211		public void testGetWaitQueueLength() throws InterruptedException {
1212		final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1213		final Condition c = lock.writeLock().newCondition();
1214	<	Thread t = new Thread(new CheckedRunnable() {
1214	>	Thread t = newStartedThread(new CheckedRunnable() {
1215		public void realRun() throws InterruptedException {
1216		lock.writeLock().lock();
1217	<	threadAssertFalse(lock.hasWaiters(c));
1218	<	threadAssertEquals(0, lock.getWaitQueueLength(c));
1217	>	assertFalse(lock.hasWaiters(c));
1218	>	assertEquals(0, lock.getWaitQueueLength(c));
1219		c.await();
1220		lock.writeLock().unlock();
1221		}});
1222
1263	–	t.start();
1223		Thread.sleep(SHORT_DELAY_MS);
1224		lock.writeLock().lock();
1225		assertTrue(lock.hasWaiters(c));
#	Line 1272 | Line 1231 | public class ReentrantReadWriteLockTest
1231		assertFalse(lock.hasWaiters(c));
1232		assertEquals(0, lock.getWaitQueueLength(c));
1233		lock.writeLock().unlock();
1234	<	t.join(SHORT_DELAY_MS);
1276	<	assertFalse(t.isAlive());
1234	>	awaitTermination(t, LONG_DELAY_MS);
1235		}
1236
1237
#	Line 1286 | Line 1244 | public class ReentrantReadWriteLockTest
1244		Thread t1 = new Thread(new CheckedRunnable() {
1245		public void realRun() throws InterruptedException {
1246		lock.writeLock().lock();
1247	<	threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
1247	>	assertTrue(lock.getWaitingThreads(c).isEmpty());
1248		c.await();
1249		lock.writeLock().unlock();
1250		}});
#	Line 1294 | Line 1252 | public class ReentrantReadWriteLockTest
1252		Thread t2 = new Thread(new CheckedRunnable() {
1253		public void realRun() throws InterruptedException {
1254		lock.writeLock().lock();
1255	<	threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
1255	>	assertFalse(lock.getWaitingThreads(c).isEmpty());
1256		c.await();
1257		lock.writeLock().unlock();
1258		}});
#	Line 1317 | Line 1275 | public class ReentrantReadWriteLockTest
1275		assertFalse(lock.hasWaiters(c));
1276		assertTrue(lock.getWaitingThreads(c).isEmpty());
1277		lock.writeLock().unlock();
1278	<	t1.join(SHORT_DELAY_MS);
1279	<	t2.join(SHORT_DELAY_MS);
1322	<	assertFalse(t1.isAlive());
1323	<	assertFalse(t2.isAlive());
1278	>	awaitTermination(t1, LONG_DELAY_MS);
1279	>	awaitTermination(t2, LONG_DELAY_MS);
1280		}
1281
1282		/**

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines