/[cvs]/jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java
ViewVC logotype

Contents of /jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.29 - (show annotations)
Sat Nov 21 02:07:26 2009 UTC (9 years, 9 months ago) by jsr166
Branch: MAIN
Changes since 1.28: +93 -93 lines
untabify

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
10 import junit.framework.*;
11 import java.util.*;
12 import java.util.concurrent.*;
13 import java.util.concurrent.locks.*;
14 import java.io.*;
15
16 public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
17 public static void main(String[] args) {
18 junit.textui.TestRunner.run (suite());
19 }
20 public static Test suite() {
21 return new TestSuite(AbstractQueuedSynchronizerTest.class);
22 }
23
24 /**
25 * A simple mutex class, adapted from the
26 * AbstractQueuedSynchronizer javadoc. Exclusive acquire tests
27 * exercise this as a sample user extension. Other
28 * methods/features of AbstractQueuedSynchronizerTest are tested
29 * via other test classes, including those for ReentrantLock,
30 * ReentrantReadWriteLock, and Semaphore
31 */
32 static class Mutex extends AbstractQueuedSynchronizer {
33 public boolean isHeldExclusively() { return getState() == 1; }
34
35 public boolean tryAcquire(int acquires) {
36 assertTrue(acquires == 1);
37 return compareAndSetState(0, 1);
38 }
39
40 public boolean tryRelease(int releases) {
41 if (getState() == 0) throw new IllegalMonitorStateException();
42 setState(0);
43 return true;
44 }
45
46 public AbstractQueuedSynchronizer.ConditionObject newCondition() { return new AbstractQueuedSynchronizer.ConditionObject(); }
47
48 }
49
50
51 /**
52 * A simple latch class, to test shared mode.
53 */
54 static class BooleanLatch extends AbstractQueuedSynchronizer {
55 public boolean isSignalled() { return getState() != 0; }
56
57 public int tryAcquireShared(int ignore) {
58 return isSignalled()? 1 : -1;
59 }
60
61 public boolean tryReleaseShared(int ignore) {
62 setState(1);
63 return true;
64 }
65 }
66
67 /**
68 * A runnable calling acquireInterruptibly that does not expect to
69 * be interrupted.
70 */
71 class InterruptibleSyncRunnable extends CheckedRunnable {
72 final Mutex sync;
73 InterruptibleSyncRunnable(Mutex l) { sync = l; }
74 public void realRun() throws InterruptedException {
75 sync.acquireInterruptibly(1);
76 }
77 }
78
79
80 /**
81 * A runnable calling acquireInterruptibly that expects to be
82 * interrupted.
83 */
84 class InterruptedSyncRunnable extends CheckedInterruptedRunnable {
85 final Mutex sync;
86 InterruptedSyncRunnable(Mutex l) { sync = l; }
87 public void realRun() throws InterruptedException {
88 sync.acquireInterruptibly(1);
89 }
90 }
91
92 /**
93 * isHeldExclusively is false upon construction
94 */
95 public void testIsHeldExclusively() {
96 Mutex rl = new Mutex();
97 assertFalse(rl.isHeldExclusively());
98 }
99
100 /**
101 * acquiring released sync succeeds
102 */
103 public void testAcquire() {
104 Mutex rl = new Mutex();
105 rl.acquire(1);
106 assertTrue(rl.isHeldExclusively());
107 rl.release(1);
108 assertFalse(rl.isHeldExclusively());
109 }
110
111 /**
112 * tryAcquire on an released sync succeeds
113 */
114 public void testTryAcquire() {
115 Mutex rl = new Mutex();
116 assertTrue(rl.tryAcquire(1));
117 assertTrue(rl.isHeldExclusively());
118 rl.release(1);
119 }
120
121 /**
122 * hasQueuedThreads reports whether there are waiting threads
123 */
124 public void testhasQueuedThreads() throws InterruptedException {
125 final Mutex sync = new Mutex();
126 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
127 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
128 assertFalse(sync.hasQueuedThreads());
129 sync.acquire(1);
130 t1.start();
131 Thread.sleep(SHORT_DELAY_MS);
132 assertTrue(sync.hasQueuedThreads());
133 t2.start();
134 Thread.sleep(SHORT_DELAY_MS);
135 assertTrue(sync.hasQueuedThreads());
136 t1.interrupt();
137 Thread.sleep(SHORT_DELAY_MS);
138 assertTrue(sync.hasQueuedThreads());
139 sync.release(1);
140 Thread.sleep(SHORT_DELAY_MS);
141 assertFalse(sync.hasQueuedThreads());
142 t1.join();
143 t2.join();
144 }
145
146 /**
147 * isQueued(null) throws NPE
148 */
149 public void testIsQueuedNPE() {
150 final Mutex sync = new Mutex();
151 try {
152 sync.isQueued(null);
153 shouldThrow();
154 } catch (NullPointerException success) {}
155 }
156
157 /**
158 * isQueued reports whether a thread is queued.
159 */
160 public void testIsQueued() throws InterruptedException {
161 final Mutex sync = new Mutex();
162 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
163 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
164 assertFalse(sync.isQueued(t1));
165 assertFalse(sync.isQueued(t2));
166 sync.acquire(1);
167 t1.start();
168 Thread.sleep(SHORT_DELAY_MS);
169 assertTrue(sync.isQueued(t1));
170 t2.start();
171 Thread.sleep(SHORT_DELAY_MS);
172 assertTrue(sync.isQueued(t1));
173 assertTrue(sync.isQueued(t2));
174 t1.interrupt();
175 Thread.sleep(SHORT_DELAY_MS);
176 assertFalse(sync.isQueued(t1));
177 assertTrue(sync.isQueued(t2));
178 sync.release(1);
179 Thread.sleep(SHORT_DELAY_MS);
180 assertFalse(sync.isQueued(t1));
181 Thread.sleep(SHORT_DELAY_MS);
182 assertFalse(sync.isQueued(t2));
183 t1.join();
184 t2.join();
185 }
186
187 /**
188 * getFirstQueuedThread returns first waiting thread or null if none
189 */
190 public void testGetFirstQueuedThread() throws InterruptedException {
191 final Mutex sync = new Mutex();
192 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
193 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
194 assertNull(sync.getFirstQueuedThread());
195 sync.acquire(1);
196 t1.start();
197 Thread.sleep(SHORT_DELAY_MS);
198 assertEquals(t1, sync.getFirstQueuedThread());
199 t2.start();
200 Thread.sleep(SHORT_DELAY_MS);
201 assertEquals(t1, sync.getFirstQueuedThread());
202 t1.interrupt();
203 Thread.sleep(SHORT_DELAY_MS);
204 Thread.sleep(SHORT_DELAY_MS);
205 assertEquals(t2, sync.getFirstQueuedThread());
206 sync.release(1);
207 Thread.sleep(SHORT_DELAY_MS);
208 assertNull(sync.getFirstQueuedThread());
209 t1.join();
210 t2.join();
211 }
212
213
214 /**
215 * hasContended reports false if no thread has ever blocked, else true
216 */
217 public void testHasContended() throws InterruptedException {
218 final Mutex sync = new Mutex();
219 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
220 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
221 assertFalse(sync.hasContended());
222 sync.acquire(1);
223 t1.start();
224 Thread.sleep(SHORT_DELAY_MS);
225 assertTrue(sync.hasContended());
226 t2.start();
227 Thread.sleep(SHORT_DELAY_MS);
228 assertTrue(sync.hasContended());
229 t1.interrupt();
230 Thread.sleep(SHORT_DELAY_MS);
231 assertTrue(sync.hasContended());
232 sync.release(1);
233 Thread.sleep(SHORT_DELAY_MS);
234 assertTrue(sync.hasContended());
235 t1.join();
236 t2.join();
237 }
238
239 /**
240 * getQueuedThreads includes waiting threads
241 */
242 public void testGetQueuedThreads() throws InterruptedException {
243 final Mutex sync = new Mutex();
244 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
245 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
246 assertTrue(sync.getQueuedThreads().isEmpty());
247 sync.acquire(1);
248 assertTrue(sync.getQueuedThreads().isEmpty());
249 t1.start();
250 Thread.sleep(SHORT_DELAY_MS);
251 assertTrue(sync.getQueuedThreads().contains(t1));
252 t2.start();
253 Thread.sleep(SHORT_DELAY_MS);
254 assertTrue(sync.getQueuedThreads().contains(t1));
255 assertTrue(sync.getQueuedThreads().contains(t2));
256 t1.interrupt();
257 Thread.sleep(SHORT_DELAY_MS);
258 assertFalse(sync.getQueuedThreads().contains(t1));
259 assertTrue(sync.getQueuedThreads().contains(t2));
260 sync.release(1);
261 Thread.sleep(SHORT_DELAY_MS);
262 assertTrue(sync.getQueuedThreads().isEmpty());
263 t1.join();
264 t2.join();
265 }
266
267 /**
268 * getExclusiveQueuedThreads includes waiting threads
269 */
270 public void testGetExclusiveQueuedThreads() throws InterruptedException {
271 final Mutex sync = new Mutex();
272 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
273 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
274 assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
275 sync.acquire(1);
276 assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
277 t1.start();
278 Thread.sleep(SHORT_DELAY_MS);
279 assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
280 t2.start();
281 Thread.sleep(SHORT_DELAY_MS);
282 assertTrue(sync.getExclusiveQueuedThreads().contains(t1));
283 assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
284 t1.interrupt();
285 Thread.sleep(SHORT_DELAY_MS);
286 assertFalse(sync.getExclusiveQueuedThreads().contains(t1));
287 assertTrue(sync.getExclusiveQueuedThreads().contains(t2));
288 sync.release(1);
289 Thread.sleep(SHORT_DELAY_MS);
290 assertTrue(sync.getExclusiveQueuedThreads().isEmpty());
291 t1.join();
292 t2.join();
293 }
294
295 /**
296 * getSharedQueuedThreads does not include exclusively waiting threads
297 */
298 public void testGetSharedQueuedThreads() throws InterruptedException {
299 final Mutex sync = new Mutex();
300 Thread t1 = new Thread(new InterruptedSyncRunnable(sync));
301 Thread t2 = new Thread(new InterruptibleSyncRunnable(sync));
302 assertTrue(sync.getSharedQueuedThreads().isEmpty());
303 sync.acquire(1);
304 assertTrue(sync.getSharedQueuedThreads().isEmpty());
305 t1.start();
306 Thread.sleep(SHORT_DELAY_MS);
307 assertTrue(sync.getSharedQueuedThreads().isEmpty());
308 t2.start();
309 Thread.sleep(SHORT_DELAY_MS);
310 assertTrue(sync.getSharedQueuedThreads().isEmpty());
311 t1.interrupt();
312 Thread.sleep(SHORT_DELAY_MS);
313 assertTrue(sync.getSharedQueuedThreads().isEmpty());
314 sync.release(1);
315 Thread.sleep(SHORT_DELAY_MS);
316 assertTrue(sync.getSharedQueuedThreads().isEmpty());
317 t1.join();
318 t2.join();
319 }
320
321 /**
322 * tryAcquireNanos is interruptible.
323 */
324 public void testInterruptedException2() throws InterruptedException {
325 final Mutex sync = new Mutex();
326 sync.acquire(1);
327 Thread t = new Thread(new CheckedInterruptedRunnable() {
328 public void realRun() throws InterruptedException {
329 sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000);
330 }});
331
332 t.start();
333 t.interrupt();
334 t.join();
335 }
336
337
338 /**
339 * TryAcquire on exclusively held sync fails
340 */
341 public void testTryAcquireWhenSynced() throws InterruptedException {
342 final Mutex sync = new Mutex();
343 sync.acquire(1);
344 Thread t = new Thread(new CheckedRunnable() {
345 public void realRun() {
346 threadAssertFalse(sync.tryAcquire(1));
347 }});
348
349 t.start();
350 t.join();
351 sync.release(1);
352 }
353
354 /**
355 * tryAcquireNanos on an exclusively held sync times out
356 */
357 public void testAcquireNanos_Timeout() throws InterruptedException {
358 final Mutex sync = new Mutex();
359 sync.acquire(1);
360 Thread t = new Thread(new CheckedRunnable() {
361 public void realRun() throws InterruptedException {
362 threadAssertFalse(sync.tryAcquireNanos(1, 1000 * 1000));
363 }});
364
365 t.start();
366 t.join();
367 sync.release(1);
368 }
369
370
371 /**
372 * getState is true when acquired and false when not
373 */
374 public void testGetState() throws InterruptedException {
375 final Mutex sync = new Mutex();
376 sync.acquire(1);
377 assertTrue(sync.isHeldExclusively());
378 sync.release(1);
379 assertFalse(sync.isHeldExclusively());
380 Thread t = new Thread(new CheckedRunnable() {
381 public void realRun() throws InterruptedException {
382 sync.acquire(1);
383 Thread.sleep(SMALL_DELAY_MS);
384 sync.release(1);
385 }});
386
387 t.start();
388 Thread.sleep(SHORT_DELAY_MS);
389 assertTrue(sync.isHeldExclusively());
390 t.join();
391 assertFalse(sync.isHeldExclusively());
392 }
393
394
395 /**
396 * acquireInterruptibly is interruptible.
397 */
398 public void testAcquireInterruptibly1() throws InterruptedException {
399 final Mutex sync = new Mutex();
400 sync.acquire(1);
401 Thread t = new Thread(new InterruptedSyncRunnable(sync));
402
403 t.start();
404 Thread.sleep(SHORT_DELAY_MS);
405 t.interrupt();
406 Thread.sleep(SHORT_DELAY_MS);
407 sync.release(1);
408 t.join();
409 }
410
411 /**
412 * acquireInterruptibly succeeds when released, else is interruptible
413 */
414 public void testAcquireInterruptibly2() throws InterruptedException {
415 final Mutex sync = new Mutex();
416 sync.acquireInterruptibly(1);
417 Thread t = new Thread(new InterruptedSyncRunnable(sync));
418 t.start();
419 t.interrupt();
420 assertTrue(sync.isHeldExclusively());
421 t.join();
422 }
423
424 /**
425 * owns is true for a condition created by sync else false
426 */
427 public void testOwns() {
428 final Mutex sync = new Mutex();
429 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
430 final Mutex sync2 = new Mutex();
431 assertTrue(sync.owns(c));
432 assertFalse(sync2.owns(c));
433 }
434
435 /**
436 * Calling await without holding sync throws IllegalMonitorStateException
437 */
438 public void testAwait_IllegalMonitor() throws InterruptedException {
439 final Mutex sync = new Mutex();
440 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
441 try {
442 c.await();
443 shouldThrow();
444 } catch (IllegalMonitorStateException success) {}
445 }
446
447 /**
448 * Calling signal without holding sync throws IllegalMonitorStateException
449 */
450 public void testSignal_IllegalMonitor() {
451 final Mutex sync = new Mutex();
452 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
453 try {
454 c.signal();
455 shouldThrow();
456 } catch (IllegalMonitorStateException success) {}
457 }
458
459 /**
460 * awaitNanos without a signal times out
461 */
462 public void testAwaitNanos_Timeout() throws InterruptedException {
463 final Mutex sync = new Mutex();
464 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
465 sync.acquire(1);
466 long t = c.awaitNanos(100);
467 assertTrue(t <= 0);
468 sync.release(1);
469 }
470
471 /**
472 * Timed await without a signal times out
473 */
474 public void testAwait_Timeout() throws InterruptedException {
475 final Mutex sync = new Mutex();
476 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
477 sync.acquire(1);
478 assertFalse(c.await(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
479 sync.release(1);
480 }
481
482 /**
483 * awaitUntil without a signal times out
484 */
485 public void testAwaitUntil_Timeout() throws InterruptedException {
486 final Mutex sync = new Mutex();
487 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
488 sync.acquire(1);
489 java.util.Date d = new java.util.Date();
490 assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + 10)));
491 sync.release(1);
492 }
493
494 /**
495 * await returns when signalled
496 */
497 public void testAwait() throws InterruptedException {
498 final Mutex sync = new Mutex();
499 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
500 Thread t = new Thread(new CheckedRunnable() {
501 public void realRun() throws InterruptedException {
502 sync.acquire(1);
503 c.await();
504 sync.release(1);
505 }});
506
507 t.start();
508 Thread.sleep(SHORT_DELAY_MS);
509 sync.acquire(1);
510 c.signal();
511 sync.release(1);
512 t.join(SHORT_DELAY_MS);
513 assertFalse(t.isAlive());
514 }
515
516
517
518 /**
519 * hasWaiters throws NPE if null
520 */
521 public void testHasWaitersNPE() {
522 final Mutex sync = new Mutex();
523 try {
524 sync.hasWaiters(null);
525 shouldThrow();
526 } catch (NullPointerException success) {}
527 }
528
529 /**
530 * getWaitQueueLength throws NPE if null
531 */
532 public void testGetWaitQueueLengthNPE() {
533 final Mutex sync = new Mutex();
534 try {
535 sync.getWaitQueueLength(null);
536 shouldThrow();
537 } catch (NullPointerException success) {}
538 }
539
540
541 /**
542 * getWaitingThreads throws NPE if null
543 */
544 public void testGetWaitingThreadsNPE() {
545 final Mutex sync = new Mutex();
546 try {
547 sync.getWaitingThreads(null);
548 shouldThrow();
549 } catch (NullPointerException success) {}
550 }
551
552
553 /**
554 * hasWaiters throws IAE if not owned
555 */
556 public void testHasWaitersIAE() {
557 final Mutex sync = new Mutex();
558 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
559 final Mutex sync2 = new Mutex();
560 try {
561 sync2.hasWaiters(c);
562 shouldThrow();
563 } catch (IllegalArgumentException success) {}
564 }
565
566 /**
567 * hasWaiters throws IMSE if not synced
568 */
569 public void testHasWaitersIMSE() {
570 final Mutex sync = new Mutex();
571 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
572 try {
573 sync.hasWaiters(c);
574 shouldThrow();
575 } catch (IllegalMonitorStateException success) {}
576 }
577
578
579 /**
580 * getWaitQueueLength throws IAE if not owned
581 */
582 public void testGetWaitQueueLengthIAE() {
583 final Mutex sync = new Mutex();
584 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
585 final Mutex sync2 = new Mutex();
586 try {
587 sync2.getWaitQueueLength(c);
588 shouldThrow();
589 } catch (IllegalArgumentException success) {}
590 }
591
592 /**
593 * getWaitQueueLength throws IMSE if not synced
594 */
595 public void testGetWaitQueueLengthIMSE() {
596 final Mutex sync = new Mutex();
597 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
598 try {
599 sync.getWaitQueueLength(c);
600 shouldThrow();
601 } catch (IllegalMonitorStateException success) {}
602 }
603
604
605 /**
606 * getWaitingThreads throws IAE if not owned
607 */
608 public void testGetWaitingThreadsIAE() {
609 final Mutex sync = new Mutex();
610 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
611 final Mutex sync2 = new Mutex();
612 try {
613 sync2.getWaitingThreads(c);
614 shouldThrow();
615 } catch (IllegalArgumentException success) {}
616 }
617
618 /**
619 * getWaitingThreads throws IMSE if not synced
620 */
621 public void testGetWaitingThreadsIMSE() {
622 final Mutex sync = new Mutex();
623 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
624 try {
625 sync.getWaitingThreads(c);
626 shouldThrow();
627 } catch (IllegalMonitorStateException success) {}
628 }
629
630
631
632 /**
633 * hasWaiters returns true when a thread is waiting, else false
634 */
635 public void testHasWaiters() throws InterruptedException {
636 final Mutex sync = new Mutex();
637 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
638 Thread t = new Thread(new CheckedRunnable() {
639 public void realRun() throws InterruptedException {
640 sync.acquire(1);
641 threadAssertFalse(sync.hasWaiters(c));
642 threadAssertEquals(0, sync.getWaitQueueLength(c));
643 c.await();
644 sync.release(1);
645 }});
646
647 t.start();
648 Thread.sleep(SHORT_DELAY_MS);
649 sync.acquire(1);
650 assertTrue(sync.hasWaiters(c));
651 assertEquals(1, sync.getWaitQueueLength(c));
652 c.signal();
653 sync.release(1);
654 Thread.sleep(SHORT_DELAY_MS);
655 sync.acquire(1);
656 assertFalse(sync.hasWaiters(c));
657 assertEquals(0, sync.getWaitQueueLength(c));
658 sync.release(1);
659 t.join(SHORT_DELAY_MS);
660 assertFalse(t.isAlive());
661 }
662
663 /**
664 * getWaitQueueLength returns number of waiting threads
665 */
666 public void testGetWaitQueueLength() throws InterruptedException {
667 final Mutex sync = new Mutex();
668 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
669 Thread t1 = new Thread(new CheckedRunnable() {
670 public void realRun() throws InterruptedException {
671 sync.acquire(1);
672 threadAssertFalse(sync.hasWaiters(c));
673 threadAssertEquals(0, sync.getWaitQueueLength(c));
674 c.await();
675 sync.release(1);
676 }});
677
678 Thread t2 = new Thread(new CheckedRunnable() {
679 public void realRun() throws InterruptedException {
680 sync.acquire(1);
681 threadAssertTrue(sync.hasWaiters(c));
682 threadAssertEquals(1, sync.getWaitQueueLength(c));
683 c.await();
684 sync.release(1);
685 }});
686
687 t1.start();
688 Thread.sleep(SHORT_DELAY_MS);
689 t2.start();
690 Thread.sleep(SHORT_DELAY_MS);
691 sync.acquire(1);
692 assertTrue(sync.hasWaiters(c));
693 assertEquals(2, sync.getWaitQueueLength(c));
694 c.signalAll();
695 sync.release(1);
696 Thread.sleep(SHORT_DELAY_MS);
697 sync.acquire(1);
698 assertFalse(sync.hasWaiters(c));
699 assertEquals(0, sync.getWaitQueueLength(c));
700 sync.release(1);
701 t1.join(SHORT_DELAY_MS);
702 t2.join(SHORT_DELAY_MS);
703 assertFalse(t1.isAlive());
704 assertFalse(t2.isAlive());
705 }
706
707 /**
708 * getWaitingThreads returns only and all waiting threads
709 */
710 public void testGetWaitingThreads() throws InterruptedException {
711 final Mutex sync = new Mutex();
712 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
713 Thread t1 = new Thread(new CheckedRunnable() {
714 public void realRun() throws InterruptedException {
715 sync.acquire(1);
716 threadAssertTrue(sync.getWaitingThreads(c).isEmpty());
717 c.await();
718 sync.release(1);
719 }});
720
721 Thread t2 = new Thread(new CheckedRunnable() {
722 public void realRun() throws InterruptedException {
723 sync.acquire(1);
724 threadAssertFalse(sync.getWaitingThreads(c).isEmpty());
725 c.await();
726 sync.release(1);
727 }});
728
729 sync.acquire(1);
730 assertTrue(sync.getWaitingThreads(c).isEmpty());
731 sync.release(1);
732 t1.start();
733 Thread.sleep(SHORT_DELAY_MS);
734 t2.start();
735 Thread.sleep(SHORT_DELAY_MS);
736 sync.acquire(1);
737 assertTrue(sync.hasWaiters(c));
738 assertTrue(sync.getWaitingThreads(c).contains(t1));
739 assertTrue(sync.getWaitingThreads(c).contains(t2));
740 c.signalAll();
741 sync.release(1);
742 Thread.sleep(SHORT_DELAY_MS);
743 sync.acquire(1);
744 assertFalse(sync.hasWaiters(c));
745 assertTrue(sync.getWaitingThreads(c).isEmpty());
746 sync.release(1);
747 t1.join(SHORT_DELAY_MS);
748 t2.join(SHORT_DELAY_MS);
749 assertFalse(t1.isAlive());
750 assertFalse(t2.isAlive());
751 }
752
753
754
755 /**
756 * awaitUninterruptibly doesn't abort on interrupt
757 */
758 public void testAwaitUninterruptibly() throws InterruptedException {
759 final Mutex sync = new Mutex();
760 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
761 Thread t = new Thread(new CheckedRunnable() {
762 public void realRun() {
763 sync.acquire(1);
764 c.awaitUninterruptibly();
765 sync.release(1);
766 }});
767
768 t.start();
769 Thread.sleep(SHORT_DELAY_MS);
770 t.interrupt();
771 sync.acquire(1);
772 c.signal();
773 sync.release(1);
774 t.join(SHORT_DELAY_MS);
775 assertFalse(t.isAlive());
776 }
777
778 /**
779 * await is interruptible
780 */
781 public void testAwait_Interrupt() throws InterruptedException {
782 final Mutex sync = new Mutex();
783 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
784 Thread t = new Thread(new CheckedInterruptedRunnable() {
785 public void realRun() throws InterruptedException {
786 sync.acquire(1);
787 c.await();
788 sync.release(1);
789 }});
790
791 t.start();
792 Thread.sleep(SHORT_DELAY_MS);
793 t.interrupt();
794 t.join(SHORT_DELAY_MS);
795 assertFalse(t.isAlive());
796 }
797
798 /**
799 * awaitNanos is interruptible
800 */
801 public void testAwaitNanos_Interrupt() throws InterruptedException {
802 final Mutex sync = new Mutex();
803 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
804 Thread t = new Thread(new CheckedInterruptedRunnable() {
805 public void realRun() throws InterruptedException {
806 sync.acquire(1);
807 c.awaitNanos(1000 * 1000 * 1000); // 1 sec
808 sync.release(1);
809 }});
810
811 t.start();
812 Thread.sleep(SHORT_DELAY_MS);
813 t.interrupt();
814 t.join(SHORT_DELAY_MS);
815 assertFalse(t.isAlive());
816 }
817
818 /**
819 * awaitUntil is interruptible
820 */
821 public void testAwaitUntil_Interrupt() throws InterruptedException {
822 final Mutex sync = new Mutex();
823 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
824 Thread t = new Thread(new CheckedInterruptedRunnable() {
825 public void realRun() throws InterruptedException {
826 sync.acquire(1);
827 java.util.Date d = new java.util.Date();
828 c.awaitUntil(new java.util.Date(d.getTime() + 10000));
829 sync.release(1);
830 }});
831
832 t.start();
833 Thread.sleep(SHORT_DELAY_MS);
834 t.interrupt();
835 t.join(SHORT_DELAY_MS);
836 assertFalse(t.isAlive());
837 }
838
839 /**
840 * signalAll wakes up all threads
841 */
842 public void testSignalAll() throws InterruptedException {
843 final Mutex sync = new Mutex();
844 final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition();
845 Thread t1 = new Thread(new CheckedRunnable() {
846 public void realRun() throws InterruptedException {
847 sync.acquire(1);
848 c.await();
849 sync.release(1);
850 }});
851
852 Thread t2 = new Thread(new CheckedRunnable() {
853 public void realRun() throws InterruptedException {
854 sync.acquire(1);
855 c.await();
856 sync.release(1);
857 }});
858
859 t1.start();
860 t2.start();
861 Thread.sleep(SHORT_DELAY_MS);
862 sync.acquire(1);
863 c.signalAll();
864 sync.release(1);
865 t1.join(SHORT_DELAY_MS);
866 t2.join(SHORT_DELAY_MS);
867 assertFalse(t1.isAlive());
868 assertFalse(t2.isAlive());
869 }
870
871
872 /**
873 * toString indicates current state
874 */
875 public void testToString() {
876 Mutex sync = new Mutex();
877 String us = sync.toString();
878 assertTrue(us.indexOf("State = 0") >= 0);
879 sync.acquire(1);
880 String ls = sync.toString();
881 assertTrue(ls.indexOf("State = 1") >= 0);
882 }
883
884 /**
885 * A serialized AQS deserializes with current state
886 */
887 public void testSerialization() throws Exception {
888 Mutex l = new Mutex();
889 l.acquire(1);
890 assertTrue(l.isHeldExclusively());
891
892 ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
893 ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
894 out.writeObject(l);
895 out.close();
896
897 ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
898 ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
899 Mutex r = (Mutex) in.readObject();
900 assertTrue(r.isHeldExclusively());
901 }
902
903
904 /**
905 * tryReleaseShared setting state changes getState
906 */
907 public void testGetStateWithReleaseShared() {
908 final BooleanLatch l = new BooleanLatch();
909 assertFalse(l.isSignalled());
910 l.releaseShared(0);
911 assertTrue(l.isSignalled());
912 }
913
914 /**
915 * releaseShared has no effect when already signalled
916 */
917 public void testReleaseShared() {
918 final BooleanLatch l = new BooleanLatch();
919 assertFalse(l.isSignalled());
920 l.releaseShared(0);
921 assertTrue(l.isSignalled());
922 l.releaseShared(0);
923 assertTrue(l.isSignalled());
924 }
925
926 /**
927 * acquireSharedInterruptibly returns after release, but not before
928 */
929 public void testAcquireSharedInterruptibly() throws InterruptedException {
930 final BooleanLatch l = new BooleanLatch();
931
932 Thread t = new Thread(new CheckedRunnable() {
933 public void realRun() throws InterruptedException {
934 threadAssertFalse(l.isSignalled());
935 l.acquireSharedInterruptibly(0);
936 threadAssertTrue(l.isSignalled());
937 }});
938
939 t.start();
940 assertFalse(l.isSignalled());
941 Thread.sleep(SHORT_DELAY_MS);
942 l.releaseShared(0);
943 assertTrue(l.isSignalled());
944 t.join();
945 }
946
947
948 /**
949 * acquireSharedTimed returns after release
950 */
951 public void testAsquireSharedTimed() throws InterruptedException {
952 final BooleanLatch l = new BooleanLatch();
953
954 Thread t = new Thread(new CheckedRunnable() {
955 public void realRun() throws InterruptedException {
956 threadAssertFalse(l.isSignalled());
957 threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000));
958 threadAssertTrue(l.isSignalled());
959 }});
960
961 t.start();
962 assertFalse(l.isSignalled());
963 Thread.sleep(SHORT_DELAY_MS);
964 l.releaseShared(0);
965 assertTrue(l.isSignalled());
966 t.join();
967 }
968
969 /**
970 * acquireSharedInterruptibly throws IE if interrupted before released
971 */
972 public void testAcquireSharedInterruptibly_InterruptedException() throws InterruptedException {
973 final BooleanLatch l = new BooleanLatch();
974 Thread t = new Thread(new CheckedInterruptedRunnable() {
975 public void realRun() throws InterruptedException {
976 threadAssertFalse(l.isSignalled());
977 l.acquireSharedInterruptibly(0);
978 }});
979
980 t.start();
981 assertFalse(l.isSignalled());
982 t.interrupt();
983 t.join();
984 }
985
986 /**
987 * acquireSharedTimed throws IE if interrupted before released
988 */
989 public void testAcquireSharedNanos_InterruptedException() throws InterruptedException {
990 final BooleanLatch l = new BooleanLatch();
991 Thread t = new Thread(new CheckedInterruptedRunnable() {
992 public void realRun() throws InterruptedException {
993 threadAssertFalse(l.isSignalled());
994 l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000);
995 }});
996
997 t.start();
998 Thread.sleep(SHORT_DELAY_MS);
999 assertFalse(l.isSignalled());
1000 t.interrupt();
1001 t.join();
1002 }
1003
1004 /**
1005 * acquireSharedTimed times out if not released before timeout
1006 */
1007 public void testAcquireSharedNanos_Timeout() throws InterruptedException {
1008 final BooleanLatch l = new BooleanLatch();
1009 Thread t = new Thread(new CheckedRunnable() {
1010 public void realRun() throws InterruptedException {
1011 threadAssertFalse(l.isSignalled());
1012 threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000));
1013 }});
1014
1015 t.start();
1016 Thread.sleep(SHORT_DELAY_MS);
1017 assertFalse(l.isSignalled());
1018 t.join();
1019 }
1020
1021 }

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27