ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ReentrantReadWriteLockTest.java
Revision: 1.19
Committed: Sun Jan 25 13:25:28 2004 UTC (20 years, 3 months ago) by dl
Branch: MAIN
CVS Tags: JSR166_PFD
Changes since 1.18: +47 -0 lines
Log Message: 
test hasQueuedThread

File Contents

# Content
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
5 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 * Pat Fisher, Mike Judd.
7 */
8
9 import junit.framework.*;
10 import java.util.concurrent.locks.*;
11 import java.util.concurrent.*;
12 import java.io.*;
13 import java.util.*;
14
15 public class ReentrantReadWriteLockTest extends JSR166TestCase {
16 public static void main(String[] args) {
17 junit.textui.TestRunner.run (suite());
18 }
19 public static Test suite() {
20 return new TestSuite(ReentrantReadWriteLockTest.class);
21 }
22
23 /**
24 * A runnable calling lockInterruptibly
25 */
26 class InterruptibleLockRunnable implements Runnable {
27 final ReentrantReadWriteLock lock;
28 InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
29 public void run() {
30 try {
31 lock.writeLock().lockInterruptibly();
32 } catch(InterruptedException success){}
33 }
34 }
35
36
37 /**
38 * A runnable calling lockInterruptibly that expects to be
39 * interrupted
40 */
41 class InterruptedLockRunnable implements Runnable {
42 final ReentrantReadWriteLock lock;
43 InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
44 public void run() {
45 try {
46 lock.writeLock().lockInterruptibly();
47 threadShouldThrow();
48 } catch(InterruptedException success){}
49 }
50 }
51
52 /**
53 * Subclass to expose protected methods
54 */
55 static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
56 PublicReentrantReadWriteLock() { super(); }
57 public Collection<Thread> getQueuedThreads() {
58 return super.getQueuedThreads();
59 }
60 public Collection<Thread> getWaitingThreads(Condition c) {
61 return super.getWaitingThreads(c);
62 }
63 }
64
65 /**
66 * Constructor sets given fairness, and is in unlocked state
67 */
68 public void testConstructor() {
69 ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
70 assertFalse(rl.isFair());
71 assertFalse(rl.isWriteLocked());
72 assertEquals(0, rl.getReadLockCount());
73 ReentrantReadWriteLock r2 = new ReentrantReadWriteLock(true);
74 assertTrue(r2.isFair());
75 assertFalse(r2.isWriteLocked());
76 assertEquals(0, r2.getReadLockCount());
77 }
78
79 /**
80 * write-locking and read-locking an unlocked lock succeed
81 */
82 public void testLock() {
83 ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
84 rl.writeLock().lock();
85 assertTrue(rl.isWriteLocked());
86 assertTrue(rl.isWriteLockedByCurrentThread());
87 assertEquals(0, rl.getReadLockCount());
88 rl.writeLock().unlock();
89 assertFalse(rl.isWriteLocked());
90 assertFalse(rl.isWriteLockedByCurrentThread());
91 assertEquals(0, rl.getReadLockCount());
92 rl.readLock().lock();
93 assertFalse(rl.isWriteLocked());
94 assertFalse(rl.isWriteLockedByCurrentThread());
95 assertEquals(1, rl.getReadLockCount());
96 rl.readLock().unlock();
97 assertFalse(rl.isWriteLocked());
98 assertFalse(rl.isWriteLockedByCurrentThread());
99 assertEquals(0, rl.getReadLockCount());
100 }
101
102
103 /**
104 * locking an unlocked fair lock succeeds
105 */
106 public void testFairLock() {
107 ReentrantReadWriteLock rl = new ReentrantReadWriteLock(true);
108 rl.writeLock().lock();
109 assertTrue(rl.isWriteLocked());
110 assertTrue(rl.isWriteLockedByCurrentThread());
111 assertEquals(0, rl.getReadLockCount());
112 rl.writeLock().unlock();
113 assertFalse(rl.isWriteLocked());
114 assertFalse(rl.isWriteLockedByCurrentThread());
115 assertEquals(0, rl.getReadLockCount());
116 rl.readLock().lock();
117 assertFalse(rl.isWriteLocked());
118 assertFalse(rl.isWriteLockedByCurrentThread());
119 assertEquals(1, rl.getReadLockCount());
120 rl.readLock().unlock();
121 assertFalse(rl.isWriteLocked());
122 assertFalse(rl.isWriteLockedByCurrentThread());
123 assertEquals(0, rl.getReadLockCount());
124 }
125
126 /**
127 * getWriteHoldCount returns number of recursive holds
128 */
129 public void testGetHoldCount() {
130 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
131 for(int i = 1; i <= SIZE; i++) {
132 lock.writeLock().lock();
133 assertEquals(i,lock.getWriteHoldCount());
134 }
135 for(int i = SIZE; i > 0; i--) {
136 lock.writeLock().unlock();
137 assertEquals(i-1,lock.getWriteHoldCount());
138 }
139 }
140
141
142 /**
143 * write-unlocking an unlocked lock throws IllegalMonitorStateException
144 */
145 public void testUnlock_IllegalMonitorStateException() {
146 ReentrantReadWriteLock rl = new ReentrantReadWriteLock();
147 try {
148 rl.writeLock().unlock();
149 shouldThrow();
150 } catch(IllegalMonitorStateException success){}
151 }
152
153
154 /**
155 * write-lockInterruptibly is interruptible
156 */
157 public void testWriteLockInterruptibly_Interrupted() {
158 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
159 Thread t = new Thread(new Runnable() {
160 public void run() {
161 try {
162 lock.writeLock().lockInterruptibly();
163 lock.writeLock().unlock();
164 lock.writeLock().lockInterruptibly();
165 lock.writeLock().unlock();
166 } catch(InterruptedException success){}
167 }
168 });
169 try {
170 lock.writeLock().lock();
171 t.start();
172 t.interrupt();
173 lock.writeLock().unlock();
174 t.join();
175 } catch(Exception e){
176 unexpectedException();
177 }
178 }
179
180 /**
181 * timed write-tryLock is interruptible
182 */
183 public void testWriteTryLock_Interrupted() {
184 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
185 lock.writeLock().lock();
186 Thread t = new Thread(new Runnable() {
187 public void run() {
188 try {
189 lock.writeLock().tryLock(1000,TimeUnit.MILLISECONDS);
190 } catch(InterruptedException success){}
191 }
192 });
193 try {
194 t.start();
195 t.interrupt();
196 lock.writeLock().unlock();
197 t.join();
198 } catch(Exception e){
199 unexpectedException();
200 }
201 }
202
203 /**
204 * read-lockInterruptibly is interruptible
205 */
206 public void testReadLockInterruptibly_Interrupted() {
207 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
208 lock.writeLock().lock();
209 Thread t = new Thread(new Runnable() {
210 public void run() {
211 try {
212 lock.readLock().lockInterruptibly();
213 } catch(InterruptedException success){}
214 }
215 });
216 try {
217 t.start();
218 t.interrupt();
219 lock.writeLock().unlock();
220 t.join();
221 } catch(Exception e){
222 unexpectedException();
223 }
224 }
225
226 /**
227 * timed read-tryLock is interruptible
228 */
229 public void testReadTryLock_Interrupted() {
230 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
231 lock.writeLock().lock();
232 Thread t = new Thread(new Runnable() {
233 public void run() {
234 try {
235 lock.readLock().tryLock(1000,TimeUnit.MILLISECONDS);
236 threadShouldThrow();
237 } catch(InterruptedException success){}
238 }
239 });
240 try {
241 t.start();
242 t.interrupt();
243 t.join();
244 } catch(Exception e){
245 unexpectedException();
246 }
247 }
248
249
250 /**
251 * write-tryLock fails if locked
252 */
253 public void testWriteTryLockWhenLocked() {
254 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
255 lock.writeLock().lock();
256 Thread t = new Thread(new Runnable() {
257 public void run() {
258 threadAssertFalse(lock.writeLock().tryLock());
259 }
260 });
261 try {
262 t.start();
263 t.join();
264 lock.writeLock().unlock();
265 } catch(Exception e){
266 unexpectedException();
267 }
268 }
269
270 /**
271 * read-tryLock fails if locked
272 */
273 public void testReadTryLockWhenLocked() {
274 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
275 lock.writeLock().lock();
276 Thread t = new Thread(new Runnable() {
277 public void run() {
278 threadAssertFalse(lock.readLock().tryLock());
279 }
280 });
281 try {
282 t.start();
283 t.join();
284 lock.writeLock().unlock();
285 } catch(Exception e){
286 unexpectedException();
287 }
288 }
289
290 /**
291 * Multiple threads can hold a read lock when not write-locked
292 */
293 public void testMultipleReadLocks() {
294 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
295 lock.readLock().lock();
296 Thread t = new Thread(new Runnable() {
297 public void run() {
298 threadAssertTrue(lock.readLock().tryLock());
299 lock.readLock().unlock();
300 }
301 });
302 try {
303 t.start();
304 t.join();
305 lock.readLock().unlock();
306 } catch(Exception e){
307 unexpectedException();
308 }
309 }
310
311 /**
312 * A writelock succeeds after reading threads unlock
313 */
314 public void testWriteAfterMultipleReadLocks() {
315 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
316 lock.readLock().lock();
317 Thread t1 = new Thread(new Runnable() {
318 public void run() {
319 lock.readLock().lock();
320 lock.readLock().unlock();
321 }
322 });
323 Thread t2 = new Thread(new Runnable() {
324 public void run() {
325 lock.writeLock().lock();
326 lock.writeLock().unlock();
327 }
328 });
329
330 try {
331 t1.start();
332 t2.start();
333 Thread.sleep(SHORT_DELAY_MS);
334 lock.readLock().unlock();
335 t1.join(MEDIUM_DELAY_MS);
336 t2.join(MEDIUM_DELAY_MS);
337 assertTrue(!t1.isAlive());
338 assertTrue(!t2.isAlive());
339
340 } catch(Exception e){
341 unexpectedException();
342 }
343 }
344
345 /**
346 * Readlocks succeed after a writing thread unlocks
347 */
348 public void testReadAfterWriteLock() {
349 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
350 lock.writeLock().lock();
351 Thread t1 = new Thread(new Runnable() {
352 public void run() {
353 lock.readLock().lock();
354 lock.readLock().unlock();
355 }
356 });
357 Thread t2 = new Thread(new Runnable() {
358 public void run() {
359 lock.readLock().lock();
360 lock.readLock().unlock();
361 }
362 });
363
364 try {
365 t1.start();
366 t2.start();
367 Thread.sleep(SHORT_DELAY_MS);
368 lock.writeLock().unlock();
369 t1.join(MEDIUM_DELAY_MS);
370 t2.join(MEDIUM_DELAY_MS);
371 assertTrue(!t1.isAlive());
372 assertTrue(!t2.isAlive());
373
374 } catch(Exception e){
375 unexpectedException();
376 }
377 }
378
379
380 /**
381 * Read tryLock succeeds if readlocked but not writelocked
382 */
383 public void testTryLockWhenReadLocked() {
384 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
385 lock.readLock().lock();
386 Thread t = new Thread(new Runnable() {
387 public void run() {
388 threadAssertTrue(lock.readLock().tryLock());
389 lock.readLock().unlock();
390 }
391 });
392 try {
393 t.start();
394 t.join();
395 lock.readLock().unlock();
396 } catch(Exception e){
397 unexpectedException();
398 }
399 }
400
401
402
403 /**
404 * write tryLock fails when readlocked
405 */
406 public void testWriteTryLockWhenReadLocked() {
407 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
408 lock.readLock().lock();
409 Thread t = new Thread(new Runnable() {
410 public void run() {
411 threadAssertFalse(lock.writeLock().tryLock());
412 }
413 });
414 try {
415 t.start();
416 t.join();
417 lock.readLock().unlock();
418 } catch(Exception e){
419 unexpectedException();
420 }
421 }
422
423
424
425 /**
426 * write timed tryLock times out if locked
427 */
428 public void testWriteTryLock_Timeout() {
429 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
430 lock.writeLock().lock();
431 Thread t = new Thread(new Runnable() {
432 public void run() {
433 try {
434 threadAssertFalse(lock.writeLock().tryLock(1, TimeUnit.MILLISECONDS));
435 } catch (Exception ex) {
436 threadUnexpectedException();
437 }
438 }
439 });
440 try {
441 t.start();
442 t.join();
443 lock.writeLock().unlock();
444 } catch(Exception e){
445 unexpectedException();
446 }
447 }
448
449 /**
450 * read timed tryLock times out if write-locked
451 */
452 public void testReadTryLock_Timeout() {
453 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
454 lock.writeLock().lock();
455 Thread t = new Thread(new Runnable() {
456 public void run() {
457 try {
458 threadAssertFalse(lock.readLock().tryLock(1, TimeUnit.MILLISECONDS));
459 } catch (Exception ex) {
460 threadUnexpectedException();
461 }
462 }
463 });
464 try {
465 t.start();
466 t.join();
467 lock.writeLock().unlock();
468 } catch(Exception e){
469 unexpectedException();
470 }
471 }
472
473
474 /**
475 * write lockInterruptibly succeeds if lock free else is interruptible
476 */
477 public void testWriteLockInterruptibly() {
478 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
479 try {
480 lock.writeLock().lockInterruptibly();
481 } catch(Exception e) {
482 unexpectedException();
483 }
484 Thread t = new Thread(new Runnable() {
485 public void run() {
486 try {
487 lock.writeLock().lockInterruptibly();
488 threadShouldThrow();
489 }
490 catch(InterruptedException success) {
491 }
492 }
493 });
494 try {
495 t.start();
496 t.interrupt();
497 t.join();
498 lock.writeLock().unlock();
499 } catch(Exception e){
500 unexpectedException();
501 }
502 }
503
504 /**
505 * read lockInterruptibly succeeds if lock free else is interruptible
506 */
507 public void testReadLockInterruptibly() {
508 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
509 try {
510 lock.writeLock().lockInterruptibly();
511 } catch(Exception e) {
512 unexpectedException();
513 }
514 Thread t = new Thread(new Runnable() {
515 public void run() {
516 try {
517 lock.readLock().lockInterruptibly();
518 threadShouldThrow();
519 }
520 catch(InterruptedException success) {
521 }
522 }
523 });
524 try {
525 t.start();
526 t.interrupt();
527 t.join();
528 lock.writeLock().unlock();
529 } catch(Exception e){
530 unexpectedException();
531 }
532 }
533
534 /**
535 * Calling await without holding lock throws IllegalMonitorStateException
536 */
537 public void testAwait_IllegalMonitor() {
538 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
539 final Condition c = lock.writeLock().newCondition();
540 try {
541 c.await();
542 shouldThrow();
543 }
544 catch (IllegalMonitorStateException success) {
545 }
546 catch (Exception ex) {
547 shouldThrow();
548 }
549 }
550
551 /**
552 * Calling signal without holding lock throws IllegalMonitorStateException
553 */
554 public void testSignal_IllegalMonitor() {
555 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
556 final Condition c = lock.writeLock().newCondition();
557 try {
558 c.signal();
559 shouldThrow();
560 }
561 catch (IllegalMonitorStateException success) {
562 }
563 catch (Exception ex) {
564 unexpectedException();
565 }
566 }
567
568 /**
569 * awaitNanos without a signal times out
570 */
571 public void testAwaitNanos_Timeout() {
572 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
573 final Condition c = lock.writeLock().newCondition();
574 try {
575 lock.writeLock().lock();
576 long t = c.awaitNanos(100);
577 assertTrue(t <= 0);
578 lock.writeLock().unlock();
579 }
580 catch (Exception ex) {
581 unexpectedException();
582 }
583 }
584
585
586 /**
587 * timed await without a signal times out
588 */
589 public void testAwait_Timeout() {
590 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
591 final Condition c = lock.writeLock().newCondition();
592 try {
593 lock.writeLock().lock();
594 assertFalse(c.await(10, TimeUnit.MILLISECONDS));
595 lock.writeLock().unlock();
596 }
597 catch (Exception ex) {
598 unexpectedException();
599 }
600 }
601
602 /**
603 * awaitUntil without a signal times out
604 */
605 public void testAwaitUntil_Timeout() {
606 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
607 final Condition c = lock.writeLock().newCondition();
608 try {
609 lock.writeLock().lock();
610 java.util.Date d = new java.util.Date();
611 assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
612 lock.writeLock().unlock();
613 }
614 catch (Exception ex) {
615 unexpectedException();
616 }
617 }
618
619 /**
620 * await returns when signalled
621 */
622 public void testAwait() {
623 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
624 final Condition c = lock.writeLock().newCondition();
625 Thread t = new Thread(new Runnable() {
626 public void run() {
627 try {
628 lock.writeLock().lock();
629 c.await();
630 lock.writeLock().unlock();
631 }
632 catch(InterruptedException e) {
633 threadUnexpectedException();
634 }
635 }
636 });
637
638 try {
639 t.start();
640 Thread.sleep(SHORT_DELAY_MS);
641 lock.writeLock().lock();
642 c.signal();
643 lock.writeLock().unlock();
644 t.join(SHORT_DELAY_MS);
645 assertFalse(t.isAlive());
646 }
647 catch (Exception ex) {
648 unexpectedException();
649 }
650 }
651
652 /**
653 * awaitUninterruptibly doesn't abort on interrupt
654 */
655 public void testAwaitUninterruptibly() {
656 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
657 final Condition c = lock.writeLock().newCondition();
658 Thread t = new Thread(new Runnable() {
659 public void run() {
660 lock.writeLock().lock();
661 c.awaitUninterruptibly();
662 lock.writeLock().unlock();
663 }
664 });
665
666 try {
667 t.start();
668 Thread.sleep(SHORT_DELAY_MS);
669 t.interrupt();
670 lock.writeLock().lock();
671 c.signal();
672 lock.writeLock().unlock();
673 assert(t.isInterrupted());
674 t.join(SHORT_DELAY_MS);
675 assertFalse(t.isAlive());
676 }
677 catch (Exception ex) {
678 unexpectedException();
679 }
680 }
681
682 /**
683 * await is interruptible
684 */
685 public void testAwait_Interrupt() {
686 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
687 final Condition c = lock.writeLock().newCondition();
688 Thread t = new Thread(new Runnable() {
689 public void run() {
690 try {
691 lock.writeLock().lock();
692 c.await();
693 lock.writeLock().unlock();
694 threadShouldThrow();
695 }
696 catch(InterruptedException success) {
697 }
698 }
699 });
700
701 try {
702 t.start();
703 Thread.sleep(SHORT_DELAY_MS);
704 t.interrupt();
705 t.join(SHORT_DELAY_MS);
706 assertFalse(t.isAlive());
707 }
708 catch (Exception ex) {
709 unexpectedException();
710 }
711 }
712
713 /**
714 * awaitNanos is interruptible
715 */
716 public void testAwaitNanos_Interrupt() {
717 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
718 final Condition c = lock.writeLock().newCondition();
719 Thread t = new Thread(new Runnable() {
720 public void run() {
721 try {
722 lock.writeLock().lock();
723 c.awaitNanos(SHORT_DELAY_MS * 2 * 1000000);
724 lock.writeLock().unlock();
725 threadShouldThrow();
726 }
727 catch(InterruptedException success) {
728 }
729 }
730 });
731
732 try {
733 t.start();
734 Thread.sleep(SHORT_DELAY_MS);
735 t.interrupt();
736 t.join(SHORT_DELAY_MS);
737 assertFalse(t.isAlive());
738 }
739 catch (Exception ex) {
740 unexpectedException();
741 }
742 }
743
744 /**
745 * awaitUntil is interruptible
746 */
747 public void testAwaitUntil_Interrupt() {
748 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
749 final Condition c = lock.writeLock().newCondition();
750 Thread t = new Thread(new Runnable() {
751 public void run() {
752 try {
753 lock.writeLock().lock();
754 java.util.Date d = new java.util.Date();
755 c.awaitUntil(new java.util.Date(d.getTime() + 10000));
756 lock.writeLock().unlock();
757 threadShouldThrow();
758 }
759 catch(InterruptedException success) {
760 }
761 }
762 });
763
764 try {
765 t.start();
766 Thread.sleep(SHORT_DELAY_MS);
767 t.interrupt();
768 t.join(SHORT_DELAY_MS);
769 assertFalse(t.isAlive());
770 }
771 catch (Exception ex) {
772 unexpectedException();
773 }
774 }
775
776 /**
777 * signalAll wakes up all threads
778 */
779 public void testSignalAll() {
780 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
781 final Condition c = lock.writeLock().newCondition();
782 Thread t1 = new Thread(new Runnable() {
783 public void run() {
784 try {
785 lock.writeLock().lock();
786 c.await();
787 lock.writeLock().unlock();
788 }
789 catch(InterruptedException e) {
790 threadUnexpectedException();
791 }
792 }
793 });
794
795 Thread t2 = new Thread(new Runnable() {
796 public void run() {
797 try {
798 lock.writeLock().lock();
799 c.await();
800 lock.writeLock().unlock();
801 }
802 catch(InterruptedException e) {
803 threadUnexpectedException();
804 }
805 }
806 });
807
808 try {
809 t1.start();
810 t2.start();
811 Thread.sleep(SHORT_DELAY_MS);
812 lock.writeLock().lock();
813 c.signalAll();
814 lock.writeLock().unlock();
815 t1.join(SHORT_DELAY_MS);
816 t2.join(SHORT_DELAY_MS);
817 assertFalse(t1.isAlive());
818 assertFalse(t2.isAlive());
819 }
820 catch (Exception ex) {
821 unexpectedException();
822 }
823 }
824
825 /**
826 * A serialized lock deserializes as unlocked
827 */
828 public void testSerialization() {
829 ReentrantReadWriteLock l = new ReentrantReadWriteLock();
830 l.readLock().lock();
831 l.readLock().unlock();
832
833 try {
834 ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
835 ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
836 out.writeObject(l);
837 out.close();
838
839 ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
840 ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
841 ReentrantReadWriteLock r = (ReentrantReadWriteLock) in.readObject();
842 r.readLock().lock();
843 r.readLock().unlock();
844 } catch(Exception e){
845 e.printStackTrace();
846 unexpectedException();
847 }
848 }
849
850 /**
851 * hasQueuedThreads reports whether there are waiting threads
852 */
853 public void testhasQueuedThreads() {
854 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
855 Thread t1 = new Thread(new InterruptedLockRunnable(lock));
856 Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
857 try {
858 assertFalse(lock.hasQueuedThreads());
859 lock.writeLock().lock();
860 t1.start();
861 Thread.sleep(SHORT_DELAY_MS);
862 assertTrue(lock.hasQueuedThreads());
863 t2.start();
864 Thread.sleep(SHORT_DELAY_MS);
865 assertTrue(lock.hasQueuedThreads());
866 t1.interrupt();
867 Thread.sleep(SHORT_DELAY_MS);
868 assertTrue(lock.hasQueuedThreads());
869 lock.writeLock().unlock();
870 Thread.sleep(SHORT_DELAY_MS);
871 assertFalse(lock.hasQueuedThreads());
872 t1.join();
873 t2.join();
874 } catch(Exception e){
875 unexpectedException();
876 }
877 }
878
879 /**
880 * hasQueuedThread(null) throws NPE
881 */
882 public void testHasQueuedThreadNPE() {
883 final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
884 try {
885 sync.hasQueuedThread(null);
886 shouldThrow();
887 } catch (NullPointerException success) {
888 }
889 }
890
891 /**
892 * hasQueuedThread reports whether a thread is queued.
893 */
894 public void testHasQueuedThread() {
895 final ReentrantReadWriteLock sync = new ReentrantReadWriteLock();
896 Thread t1 = new Thread(new InterruptedLockRunnable(sync));
897 Thread t2 = new Thread(new InterruptibleLockRunnable(sync));
898 try {
899 assertFalse(sync.hasQueuedThread(t1));
900 assertFalse(sync.hasQueuedThread(t2));
901 sync.writeLock().lock();
902 t1.start();
903 Thread.sleep(SHORT_DELAY_MS);
904 assertTrue(sync.hasQueuedThread(t1));
905 t2.start();
906 Thread.sleep(SHORT_DELAY_MS);
907 assertTrue(sync.hasQueuedThread(t1));
908 assertTrue(sync.hasQueuedThread(t2));
909 t1.interrupt();
910 Thread.sleep(SHORT_DELAY_MS);
911 assertFalse(sync.hasQueuedThread(t1));
912 assertTrue(sync.hasQueuedThread(t2));
913 sync.writeLock().unlock();
914 Thread.sleep(SHORT_DELAY_MS);
915 assertFalse(sync.hasQueuedThread(t1));
916 Thread.sleep(SHORT_DELAY_MS);
917 assertFalse(sync.hasQueuedThread(t2));
918 t1.join();
919 t2.join();
920 } catch(Exception e){
921 unexpectedException();
922 }
923 }
924
925
926 /**
927 * getQueueLength reports number of waiting threads
928 */
929 public void testGetQueueLength() {
930 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
931 Thread t1 = new Thread(new InterruptedLockRunnable(lock));
932 Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
933 try {
934 assertEquals(0, lock.getQueueLength());
935 lock.writeLock().lock();
936 t1.start();
937 Thread.sleep(SHORT_DELAY_MS);
938 assertEquals(1, lock.getQueueLength());
939 t2.start();
940 Thread.sleep(SHORT_DELAY_MS);
941 assertEquals(2, lock.getQueueLength());
942 t1.interrupt();
943 Thread.sleep(SHORT_DELAY_MS);
944 assertEquals(1, lock.getQueueLength());
945 lock.writeLock().unlock();
946 Thread.sleep(SHORT_DELAY_MS);
947 assertEquals(0, lock.getQueueLength());
948 t1.join();
949 t2.join();
950 } catch(Exception e){
951 unexpectedException();
952 }
953 }
954
955 /**
956 * getQueuedThreads includes waiting threads
957 */
958 public void testGetQueuedThreads() {
959 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
960 Thread t1 = new Thread(new InterruptedLockRunnable(lock));
961 Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
962 try {
963 assertTrue(lock.getQueuedThreads().isEmpty());
964 lock.writeLock().lock();
965 assertTrue(lock.getQueuedThreads().isEmpty());
966 t1.start();
967 Thread.sleep(SHORT_DELAY_MS);
968 assertTrue(lock.getQueuedThreads().contains(t1));
969 t2.start();
970 Thread.sleep(SHORT_DELAY_MS);
971 assertTrue(lock.getQueuedThreads().contains(t1));
972 assertTrue(lock.getQueuedThreads().contains(t2));
973 t1.interrupt();
974 Thread.sleep(SHORT_DELAY_MS);
975 assertFalse(lock.getQueuedThreads().contains(t1));
976 assertTrue(lock.getQueuedThreads().contains(t2));
977 lock.writeLock().unlock();
978 Thread.sleep(SHORT_DELAY_MS);
979 assertTrue(lock.getQueuedThreads().isEmpty());
980 t1.join();
981 t2.join();
982 } catch(Exception e){
983 unexpectedException();
984 }
985 }
986
987 /**
988 * hasWaiters throws NPE if null
989 */
990 public void testHasWaitersNPE() {
991 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
992 try {
993 lock.hasWaiters(null);
994 shouldThrow();
995 } catch (NullPointerException success) {
996 } catch (Exception ex) {
997 unexpectedException();
998 }
999 }
1000
1001 /**
1002 * getWaitQueueLength throws NPE if null
1003 */
1004 public void testGetWaitQueueLengthNPE() {
1005 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1006 try {
1007 lock.getWaitQueueLength(null);
1008 shouldThrow();
1009 } catch (NullPointerException success) {
1010 } catch (Exception ex) {
1011 unexpectedException();
1012 }
1013 }
1014
1015
1016 /**
1017 * getWaitingThreads throws NPE if null
1018 */
1019 public void testGetWaitingThreadsNPE() {
1020 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1021 try {
1022 lock.getWaitingThreads(null);
1023 shouldThrow();
1024 } catch (NullPointerException success) {
1025 } catch (Exception ex) {
1026 unexpectedException();
1027 }
1028 }
1029
1030 /**
1031 * hasWaiters throws IAE if not owned
1032 */
1033 public void testHasWaitersIAE() {
1034 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1035 final Condition c = (lock.writeLock().newCondition());
1036 final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1037 try {
1038 lock2.hasWaiters(c);
1039 shouldThrow();
1040 } catch (IllegalArgumentException success) {
1041 } catch (Exception ex) {
1042 unexpectedException();
1043 }
1044 }
1045
1046 /**
1047 * hasWaiters throws IMSE if not locked
1048 */
1049 public void testHasWaitersIMSE() {
1050 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1051 final Condition c = (lock.writeLock().newCondition());
1052 try {
1053 lock.hasWaiters(c);
1054 shouldThrow();
1055 } catch (IllegalMonitorStateException success) {
1056 } catch (Exception ex) {
1057 unexpectedException();
1058 }
1059 }
1060
1061
1062 /**
1063 * getWaitQueueLength throws IAE if not owned
1064 */
1065 public void testGetWaitQueueLengthIAE() {
1066 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1067 final Condition c = (lock.writeLock().newCondition());
1068 final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock();
1069 try {
1070 lock2.getWaitQueueLength(c);
1071 shouldThrow();
1072 } catch (IllegalArgumentException success) {
1073 } catch (Exception ex) {
1074 unexpectedException();
1075 }
1076 }
1077
1078 /**
1079 * getWaitQueueLength throws IMSE if not locked
1080 */
1081 public void testGetWaitQueueLengthIMSE() {
1082 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1083 final Condition c = (lock.writeLock().newCondition());
1084 try {
1085 lock.getWaitQueueLength(c);
1086 shouldThrow();
1087 } catch (IllegalMonitorStateException success) {
1088 } catch (Exception ex) {
1089 unexpectedException();
1090 }
1091 }
1092
1093
1094 /**
1095 * getWaitingThreads throws IAE if not owned
1096 */
1097 public void testGetWaitingThreadsIAE() {
1098 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1099 final Condition c = (lock.writeLock().newCondition());
1100 final PublicReentrantReadWriteLock lock2 = new PublicReentrantReadWriteLock();
1101 try {
1102 lock2.getWaitingThreads(c);
1103 shouldThrow();
1104 } catch (IllegalArgumentException success) {
1105 } catch (Exception ex) {
1106 unexpectedException();
1107 }
1108 }
1109
1110 /**
1111 * getWaitingThreads throws IMSE if not locked
1112 */
1113 public void testGetWaitingThreadsIMSE() {
1114 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1115 final Condition c = (lock.writeLock().newCondition());
1116 try {
1117 lock.getWaitingThreads(c);
1118 shouldThrow();
1119 } catch (IllegalMonitorStateException success) {
1120 } catch (Exception ex) {
1121 unexpectedException();
1122 }
1123 }
1124
1125
1126 /**
1127 * hasWaiters returns true when a thread is waiting, else false
1128 */
1129 public void testHasWaiters() {
1130 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1131 final Condition c = (lock.writeLock().newCondition());
1132 Thread t = new Thread(new Runnable() {
1133 public void run() {
1134 try {
1135 lock.writeLock().lock();
1136 threadAssertFalse(lock.hasWaiters(c));
1137 threadAssertEquals(0, lock.getWaitQueueLength(c));
1138 c.await();
1139 lock.writeLock().unlock();
1140 }
1141 catch(InterruptedException e) {
1142 threadUnexpectedException();
1143 }
1144 }
1145 });
1146
1147 try {
1148 t.start();
1149 Thread.sleep(SHORT_DELAY_MS);
1150 lock.writeLock().lock();
1151 assertTrue(lock.hasWaiters(c));
1152 assertEquals(1, lock.getWaitQueueLength(c));
1153 c.signal();
1154 lock.writeLock().unlock();
1155 Thread.sleep(SHORT_DELAY_MS);
1156 lock.writeLock().lock();
1157 assertFalse(lock.hasWaiters(c));
1158 assertEquals(0, lock.getWaitQueueLength(c));
1159 lock.writeLock().unlock();
1160 t.join(SHORT_DELAY_MS);
1161 assertFalse(t.isAlive());
1162 }
1163 catch (Exception ex) {
1164 unexpectedException();
1165 }
1166 }
1167
1168 /**
1169 * getWaitQueueLength returns number of waiting threads
1170 */
1171 public void testGetWaitQueueLength() {
1172 final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1173 final Condition c = (lock.writeLock().newCondition());
1174 Thread t = new Thread(new Runnable() {
1175 public void run() {
1176 try {
1177 lock.writeLock().lock();
1178 threadAssertFalse(lock.hasWaiters(c));
1179 threadAssertEquals(0, lock.getWaitQueueLength(c));
1180 c.await();
1181 lock.writeLock().unlock();
1182 }
1183 catch(InterruptedException e) {
1184 threadUnexpectedException();
1185 }
1186 }
1187 });
1188
1189 try {
1190 t.start();
1191 Thread.sleep(SHORT_DELAY_MS);
1192 lock.writeLock().lock();
1193 assertTrue(lock.hasWaiters(c));
1194 assertEquals(1, lock.getWaitQueueLength(c));
1195 c.signal();
1196 lock.writeLock().unlock();
1197 Thread.sleep(SHORT_DELAY_MS);
1198 lock.writeLock().lock();
1199 assertFalse(lock.hasWaiters(c));
1200 assertEquals(0, lock.getWaitQueueLength(c));
1201 lock.writeLock().unlock();
1202 t.join(SHORT_DELAY_MS);
1203 assertFalse(t.isAlive());
1204 }
1205 catch (Exception ex) {
1206 unexpectedException();
1207 }
1208 }
1209
1210
1211 /**
1212 * getWaitingThreads returns only and all waiting threads
1213 */
1214 public void testGetWaitingThreads() {
1215 final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock();
1216 final Condition c = lock.writeLock().newCondition();
1217 Thread t1 = new Thread(new Runnable() {
1218 public void run() {
1219 try {
1220 lock.writeLock().lock();
1221 threadAssertTrue(lock.getWaitingThreads(c).isEmpty());
1222 c.await();
1223 lock.writeLock().unlock();
1224 }
1225 catch(InterruptedException e) {
1226 threadUnexpectedException();
1227 }
1228 }
1229 });
1230
1231 Thread t2 = new Thread(new Runnable() {
1232 public void run() {
1233 try {
1234 lock.writeLock().lock();
1235 threadAssertFalse(lock.getWaitingThreads(c).isEmpty());
1236 c.await();
1237 lock.writeLock().unlock();
1238 }
1239 catch(InterruptedException e) {
1240 threadUnexpectedException();
1241 }
1242 }
1243 });
1244
1245 try {
1246 lock.writeLock().lock();
1247 assertTrue(lock.getWaitingThreads(c).isEmpty());
1248 lock.writeLock().unlock();
1249 t1.start();
1250 Thread.sleep(SHORT_DELAY_MS);
1251 t2.start();
1252 Thread.sleep(SHORT_DELAY_MS);
1253 lock.writeLock().lock();
1254 assertTrue(lock.hasWaiters(c));
1255 assertTrue(lock.getWaitingThreads(c).contains(t1));
1256 assertTrue(lock.getWaitingThreads(c).contains(t2));
1257 c.signalAll();
1258 lock.writeLock().unlock();
1259 Thread.sleep(SHORT_DELAY_MS);
1260 lock.writeLock().lock();
1261 assertFalse(lock.hasWaiters(c));
1262 assertTrue(lock.getWaitingThreads(c).isEmpty());
1263 lock.writeLock().unlock();
1264 t1.join(SHORT_DELAY_MS);
1265 t2.join(SHORT_DELAY_MS);
1266 assertFalse(t1.isAlive());
1267 assertFalse(t2.isAlive());
1268 }
1269 catch (Exception ex) {
1270 unexpectedException();
1271 }
1272 }
1273
1274 /**
1275 * toString indicates current lock state
1276 */
1277 public void testToString() {
1278 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1279 String us = lock.toString();
1280 assertTrue(us.indexOf("Write locks = 0") >= 0);
1281 assertTrue(us.indexOf("Read locks = 0") >= 0);
1282 lock.writeLock().lock();
1283 String ws = lock.toString();
1284 assertTrue(ws.indexOf("Write locks = 1") >= 0);
1285 assertTrue(ws.indexOf("Read locks = 0") >= 0);
1286 lock.writeLock().unlock();
1287 lock.readLock().lock();
1288 lock.readLock().lock();
1289 String rs = lock.toString();
1290 assertTrue(rs.indexOf("Write locks = 0") >= 0);
1291 assertTrue(rs.indexOf("Read locks = 2") >= 0);
1292 }
1293
1294 /**
1295 * readLock.toString indicates current lock state
1296 */
1297 public void testReadLockToString() {
1298 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1299 String us = lock.readLock().toString();
1300 assertTrue(us.indexOf("Read locks = 0") >= 0);
1301 lock.readLock().lock();
1302 lock.readLock().lock();
1303 String rs = lock.readLock().toString();
1304 assertTrue(rs.indexOf("Read locks = 2") >= 0);
1305 }
1306
1307 /**
1308 * writeLock.toString indicates current lock state
1309 */
1310 public void testWriteLockToString() {
1311 ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
1312 String us = lock.writeLock().toString();
1313 assertTrue(us.indexOf("Unlocked") >= 0);
1314 lock.writeLock().lock();
1315 String ls = lock.writeLock().toString();
1316 assertTrue(ls.indexOf("Locked") >= 0);
1317 }
1318
1319 }