ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/PhaserTest.java
Revision: 1.51
Committed: Tue Jan 26 13:33:06 2021 UTC (3 years, 2 months ago) by dl
Branch: MAIN
CVS Tags: HEAD
Changes since 1.50: +1 -1 lines
Log Message:
Replace Integer with Item class

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/publicdomain/zero/1.0/
5 * Other contributors include John Vint
6 */
7
8 import static java.util.concurrent.TimeUnit.MILLISECONDS;
9
10 import java.util.ArrayList;
11 import java.util.List;
12 import java.util.concurrent.CountDownLatch;
13 import java.util.concurrent.Phaser;
14 import java.util.concurrent.TimeoutException;
15 import java.util.concurrent.atomic.AtomicInteger;
16
17 import junit.framework.Test;
18 import junit.framework.TestSuite;
19
20 public class PhaserTest extends JSR166TestCase {
21
22 public static void main(String[] args) {
23 main(suite(), args);
24 }
25
26 public static Test suite() {
27 return new TestSuite(PhaserTest.class);
28 }
29
30 private static final int maxParties = 65535;
31
32 /** Checks state of unterminated phaser. */
33 protected void assertState(Phaser phaser,
34 int phase, int parties, int unarrived) {
35 assertEquals(phase, phaser.getPhase());
36 assertEquals(parties, phaser.getRegisteredParties());
37 assertEquals(unarrived, phaser.getUnarrivedParties());
38 assertEquals(parties - unarrived, phaser.getArrivedParties());
39 assertFalse(phaser.isTerminated());
40 }
41
42 /** Checks state of terminated phaser. */
43 protected void assertTerminated(Phaser phaser, int maxPhase, int parties) {
44 assertTrue(phaser.isTerminated());
45 int expectedPhase = maxPhase + Integer.MIN_VALUE;
46 assertEquals(expectedPhase, phaser.getPhase());
47 assertEquals(parties, phaser.getRegisteredParties());
48 assertEquals(expectedPhase, phaser.register());
49 assertEquals(expectedPhase, phaser.arrive());
50 assertEquals(expectedPhase, phaser.arriveAndDeregister());
51 }
52
53 protected void assertTerminated(Phaser phaser, int maxPhase) {
54 assertTerminated(phaser, maxPhase, 0);
55 }
56
57 /**
58 * Empty constructor builds a new Phaser with no parent, no registered
59 * parties and initial phase number of 0
60 */
61 public void testConstructorDefaultValues() {
62 Phaser phaser = new Phaser();
63 assertNull(phaser.getParent());
64 assertEquals(0, phaser.getRegisteredParties());
65 assertEquals(0, phaser.getArrivedParties());
66 assertEquals(0, phaser.getUnarrivedParties());
67 assertEquals(0, phaser.getPhase());
68 }
69
70 /**
71 * Constructing with a negative number of parties throws
72 * IllegalArgumentException
73 */
74 public void testConstructorNegativeParties() {
75 try {
76 new Phaser(-1);
77 shouldThrow();
78 } catch (IllegalArgumentException success) {}
79 }
80
81 /**
82 * Constructing with a negative number of parties throws
83 * IllegalArgumentException
84 */
85 public void testConstructorNegativeParties2() {
86 try {
87 new Phaser(new Phaser(), -1);
88 shouldThrow();
89 } catch (IllegalArgumentException success) {}
90 }
91
92 /**
93 * Constructing with a number of parties > 65535 throws
94 * IllegalArgumentException
95 */
96 public void testConstructorPartiesExceedsLimit() {
97 new Phaser(maxParties);
98 try {
99 new Phaser(maxParties + 1);
100 shouldThrow();
101 } catch (IllegalArgumentException success) {}
102
103 new Phaser(new Phaser(), maxParties);
104 try {
105 new Phaser(new Phaser(), maxParties + 1);
106 shouldThrow();
107 } catch (IllegalArgumentException success) {}
108 }
109
110 /**
111 * The parent provided to the constructor should be returned from
112 * a later call to getParent
113 */
114 public void testConstructor3() {
115 Phaser parent = new Phaser();
116 assertSame(parent, new Phaser(parent).getParent());
117 assertNull(new Phaser(null).getParent());
118 }
119
120 /**
121 * The parent being input into the parameter should equal the original
122 * parent when being returned
123 */
124 public void testConstructor5() {
125 Phaser parent = new Phaser();
126 assertSame(parent, new Phaser(parent, 0).getParent());
127 assertNull(new Phaser(null, 0).getParent());
128 }
129
130 /**
131 * register() will increment the number of unarrived parties by
132 * one and not affect its arrived parties
133 */
134 public void testRegister1() {
135 Phaser phaser = new Phaser();
136 assertState(phaser, 0, 0, 0);
137 assertEquals(0, phaser.register());
138 assertState(phaser, 0, 1, 1);
139 }
140
141 /**
142 * Registering more than 65536 parties causes IllegalStateException
143 */
144 public void testRegister2() {
145 Phaser phaser = new Phaser(0);
146 assertState(phaser, 0, 0, 0);
147 assertEquals(0, phaser.bulkRegister(maxParties - 10));
148 assertState(phaser, 0, maxParties - 10, maxParties - 10);
149 for (int i = 0; i < 10; i++) {
150 assertState(phaser, 0, maxParties - 10 + i, maxParties - 10 + i);
151 assertEquals(0, phaser.register());
152 }
153 assertState(phaser, 0, maxParties, maxParties);
154 try {
155 phaser.register();
156 shouldThrow();
157 } catch (IllegalStateException success) {}
158
159 try {
160 phaser.bulkRegister(Integer.MAX_VALUE);
161 shouldThrow();
162 } catch (IllegalStateException success) {}
163
164 assertEquals(0, phaser.bulkRegister(0));
165 assertState(phaser, 0, maxParties, maxParties);
166 }
167
168 /**
169 * register() correctly returns the current barrier phase number
170 * when invoked
171 */
172 public void testRegister3() {
173 Phaser phaser = new Phaser();
174 assertEquals(0, phaser.register());
175 assertEquals(0, phaser.arrive());
176 assertEquals(1, phaser.register());
177 assertState(phaser, 1, 2, 2);
178 }
179
180 /**
181 * register causes the next arrive to not increment the phase
182 * rather retain the phase number
183 */
184 public void testRegister4() {
185 Phaser phaser = new Phaser(1);
186 assertEquals(0, phaser.arrive());
187 assertEquals(1, phaser.register());
188 assertEquals(1, phaser.arrive());
189 assertState(phaser, 1, 2, 1);
190 }
191
192 /**
193 * register on a subphaser that is currently empty succeeds, even
194 * in the presence of another non-empty subphaser
195 */
196 public void testRegisterEmptySubPhaser() {
197 Phaser root = new Phaser();
198 Phaser child1 = new Phaser(root, 1);
199 Phaser child2 = new Phaser(root, 0);
200 assertEquals(0, child2.register());
201 assertState(root, 0, 2, 2);
202 assertState(child1, 0, 1, 1);
203 assertState(child2, 0, 1, 1);
204 assertEquals(0, child2.arriveAndDeregister());
205 assertState(root, 0, 1, 1);
206 assertState(child1, 0, 1, 1);
207 assertState(child2, 0, 0, 0);
208 assertEquals(0, child2.register());
209 assertEquals(0, child2.arriveAndDeregister());
210 assertState(root, 0, 1, 1);
211 assertState(child1, 0, 1, 1);
212 assertState(child2, 0, 0, 0);
213 assertEquals(0, child1.arriveAndDeregister());
214 assertTerminated(root, 1);
215 assertTerminated(child1, 1);
216 assertTerminated(child2, 1);
217 }
218
219 /**
220 * Invoking bulkRegister with a negative parameter throws an
221 * IllegalArgumentException
222 */
223 public void testBulkRegister1() {
224 try {
225 new Phaser().bulkRegister(-1);
226 shouldThrow();
227 } catch (IllegalArgumentException success) {}
228 }
229
230 /**
231 * bulkRegister should correctly record the number of unarrived
232 * parties with the number of parties being registered
233 */
234 public void testBulkRegister2() {
235 Phaser phaser = new Phaser();
236 assertEquals(0, phaser.bulkRegister(0));
237 assertState(phaser, 0, 0, 0);
238 assertEquals(0, phaser.bulkRegister(20));
239 assertState(phaser, 0, 20, 20);
240 }
241
242 /**
243 * Registering with a number of parties greater than or equal to 1<<16
244 * throws IllegalStateException.
245 */
246 public void testBulkRegister3() {
247 assertEquals(0, new Phaser().bulkRegister((1 << 16) - 1));
248
249 try {
250 new Phaser().bulkRegister(1 << 16);
251 shouldThrow();
252 } catch (IllegalStateException success) {}
253
254 try {
255 new Phaser(2).bulkRegister((1 << 16) - 2);
256 shouldThrow();
257 } catch (IllegalStateException success) {}
258 }
259
260 /**
261 * the phase number increments correctly when tripping the barrier
262 */
263 public void testPhaseIncrement1() {
264 for (int size = 1; size < 9; size++) {
265 final Phaser phaser = new Phaser(size);
266 for (int index = 0; index <= (1 << size); index++) {
267 int phase = phaser.arrive();
268 assertTrue(index % size == 0 ? (index / size) == phase : index - (phase * size) > 0);
269 }
270 }
271 }
272
273 /**
274 * arrive() on a registered phaser increments phase.
275 */
276 public void testArrive1() {
277 Phaser phaser = new Phaser(1);
278 assertState(phaser, 0, 1, 1);
279 assertEquals(0, phaser.arrive());
280 assertState(phaser, 1, 1, 1);
281 }
282
283 /**
284 * arriveAndDeregister does not wait for others to arrive at barrier
285 */
286 public void testArriveAndDeregister() {
287 final Phaser phaser = new Phaser(1);
288 for (int i = 0; i < 10; i++) {
289 assertState(phaser, 0, 1, 1);
290 assertEquals(0, phaser.register());
291 assertState(phaser, 0, 2, 2);
292 assertEquals(0, phaser.arriveAndDeregister());
293 assertState(phaser, 0, 1, 1);
294 }
295 assertEquals(0, phaser.arriveAndDeregister());
296 assertTerminated(phaser, 1);
297 }
298
299 /**
300 * arriveAndDeregister does not wait for others to arrive at barrier
301 */
302 public void testArrive2() {
303 final Phaser phaser = new Phaser();
304 assertEquals(0, phaser.register());
305 List<Thread> threads = new ArrayList<>();
306 for (int i = 0; i < 10; i++) {
307 assertEquals(0, phaser.register());
308 threads.add(newStartedThread(new CheckedRunnable() {
309 public void realRun() {
310 assertEquals(0, phaser.arriveAndDeregister());
311 }}));
312 }
313
314 for (Thread thread : threads)
315 awaitTermination(thread);
316 assertState(phaser, 0, 1, 1);
317 assertEquals(0, phaser.arrive());
318 assertState(phaser, 1, 1, 1);
319 }
320
321 /**
322 * arrive() returns a negative number if the Phaser is terminated
323 */
324 public void testArrive3() {
325 Phaser phaser = new Phaser(1);
326 phaser.forceTermination();
327 assertTerminated(phaser, 0, 1);
328 assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
329 assertTrue(phaser.arrive() < 0);
330 assertTrue(phaser.register() < 0);
331 assertTrue(phaser.arriveAndDeregister() < 0);
332 assertTrue(phaser.awaitAdvance(1) < 0);
333 assertTrue(phaser.getPhase() < 0);
334 }
335
336 /**
337 * arriveAndDeregister() throws IllegalStateException if number of
338 * registered or unarrived parties would become negative
339 */
340 public void testArriveAndDeregister1() {
341 Phaser phaser = new Phaser();
342 try {
343 phaser.arriveAndDeregister();
344 shouldThrow();
345 } catch (IllegalStateException success) {}
346 }
347
348 /**
349 * arriveAndDeregister reduces the number of arrived parties
350 */
351 public void testArriveAndDeregister2() {
352 final Phaser phaser = new Phaser(1);
353 assertEquals(0, phaser.register());
354 assertEquals(0, phaser.arrive());
355 assertState(phaser, 0, 2, 1);
356 assertEquals(0, phaser.arriveAndDeregister());
357 assertState(phaser, 1, 1, 1);
358 }
359
360 /**
361 * arriveAndDeregister arrives at the barrier on a phaser with a parent and
362 * when a deregistration occurs and causes the phaser to have zero parties
363 * its parent will be deregistered as well
364 */
365 public void testArriveAndDeregister3() {
366 Phaser parent = new Phaser();
367 Phaser child = new Phaser(parent);
368 assertState(child, 0, 0, 0);
369 assertState(parent, 0, 0, 0);
370 assertEquals(0, child.register());
371 assertState(child, 0, 1, 1);
372 assertState(parent, 0, 1, 1);
373 assertEquals(0, child.arriveAndDeregister());
374 assertTerminated(child, 1);
375 assertTerminated(parent, 1);
376 }
377
378 /**
379 * arriveAndDeregister deregisters one party from its parent when
380 * the number of parties of child is zero after deregistration
381 */
382 public void testArriveAndDeregister4() {
383 Phaser parent = new Phaser();
384 Phaser child = new Phaser(parent);
385 assertEquals(0, parent.register());
386 assertEquals(0, child.register());
387 assertState(child, 0, 1, 1);
388 assertState(parent, 0, 2, 2);
389 assertEquals(0, child.arriveAndDeregister());
390 assertState(child, 0, 0, 0);
391 assertState(parent, 0, 1, 1);
392 }
393
394 /**
395 * arriveAndDeregister deregisters one party from its parent when
396 * the number of parties of root is nonzero after deregistration.
397 */
398 public void testArriveAndDeregister5() {
399 Phaser root = new Phaser();
400 Phaser parent = new Phaser(root);
401 Phaser child = new Phaser(parent);
402 assertState(root, 0, 0, 0);
403 assertState(parent, 0, 0, 0);
404 assertState(child, 0, 0, 0);
405 assertEquals(0, child.register());
406 assertState(root, 0, 1, 1);
407 assertState(parent, 0, 1, 1);
408 assertState(child, 0, 1, 1);
409 assertEquals(0, child.arriveAndDeregister());
410 assertTerminated(child, 1);
411 assertTerminated(parent, 1);
412 assertTerminated(root, 1);
413 }
414
415 /**
416 * arriveAndDeregister returns the phase in which it leaves the
417 * phaser in after deregistration
418 */
419 public void testArriveAndDeregister6() {
420 final Phaser phaser = new Phaser(2);
421 Thread t = newStartedThread(new CheckedRunnable() {
422 public void realRun() {
423 assertEquals(0, phaser.arrive());
424 }});
425 assertEquals(1, phaser.arriveAndAwaitAdvance());
426 assertState(phaser, 1, 2, 2);
427 assertEquals(1, phaser.arriveAndDeregister());
428 assertState(phaser, 1, 1, 1);
429 assertEquals(1, phaser.arriveAndDeregister());
430 assertTerminated(phaser, 2);
431 awaitTermination(t);
432 }
433
434 /**
435 * awaitAdvance succeeds upon advance
436 */
437 public void testAwaitAdvance1() {
438 final Phaser phaser = new Phaser(1);
439 assertEquals(0, phaser.arrive());
440 assertEquals(1, phaser.awaitAdvance(0));
441 }
442
443 /**
444 * awaitAdvance with a negative parameter will return without affecting the
445 * phaser
446 */
447 public void testAwaitAdvance2() {
448 Phaser phaser = new Phaser();
449 assertTrue(phaser.awaitAdvance(-1) < 0);
450 assertState(phaser, 0, 0, 0);
451 }
452
453 /**
454 * awaitAdvanceInterruptibly blocks interruptibly
455 */
456 public void testAwaitAdvanceInterruptibly_Interruptible() throws InterruptedException {
457 final Phaser phaser = new Phaser(1);
458 final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
459
460 Thread t1 = newStartedThread(new CheckedRunnable() {
461 public void realRun() {
462 Thread.currentThread().interrupt();
463 try {
464 phaser.awaitAdvanceInterruptibly(0);
465 shouldThrow();
466 } catch (InterruptedException success) {}
467 assertFalse(Thread.interrupted());
468
469 pleaseInterrupt.countDown();
470 try {
471 phaser.awaitAdvanceInterruptibly(0);
472 shouldThrow();
473 } catch (InterruptedException success) {}
474 assertFalse(Thread.interrupted());
475 }});
476
477 Thread t2 = newStartedThread(new CheckedRunnable() {
478 public void realRun() throws TimeoutException {
479 Thread.currentThread().interrupt();
480 try {
481 phaser.awaitAdvanceInterruptibly(0, randomTimeout(), randomTimeUnit());
482 shouldThrow();
483 } catch (InterruptedException success) {}
484 assertFalse(Thread.interrupted());
485
486 pleaseInterrupt.countDown();
487 try {
488 phaser.awaitAdvanceInterruptibly(0, LONGER_DELAY_MS, MILLISECONDS);
489 shouldThrow();
490 } catch (InterruptedException success) {}
491 assertFalse(Thread.interrupted());
492 }});
493
494 await(pleaseInterrupt);
495 assertState(phaser, 0, 1, 1);
496 if (randomBoolean()) assertThreadBlocks(t1, Thread.State.WAITING);
497 if (randomBoolean()) assertThreadBlocks(t2, Thread.State.TIMED_WAITING);
498 t1.interrupt();
499 t2.interrupt();
500 awaitTermination(t1);
501 awaitTermination(t2);
502 assertState(phaser, 0, 1, 1);
503 assertEquals(0, phaser.arrive());
504 assertState(phaser, 1, 1, 1);
505 }
506
507 /**
508 * awaitAdvance continues waiting if interrupted before waiting
509 */
510 public void testAwaitAdvanceAfterInterrupt() {
511 final Phaser phaser = new Phaser();
512 assertEquals(0, phaser.register());
513 final CountDownLatch pleaseArrive = new CountDownLatch(1);
514
515 Thread t = newStartedThread(new CheckedRunnable() {
516 public void realRun() {
517 Thread.currentThread().interrupt();
518 assertEquals(0, phaser.register());
519 assertEquals(0, phaser.arrive());
520 pleaseArrive.countDown();
521 assertTrue(Thread.currentThread().isInterrupted());
522 assertEquals(1, phaser.awaitAdvance(0));
523 assertTrue(Thread.interrupted());
524 }});
525
526 await(pleaseArrive);
527 assertThreadBlocks(t, Thread.State.WAITING);
528 assertEquals(0, phaser.arrive());
529 awaitTermination(t);
530
531 Thread.currentThread().interrupt();
532 assertEquals(1, phaser.awaitAdvance(0));
533 assertTrue(Thread.interrupted());
534 }
535
536 /**
537 * awaitAdvance continues waiting if interrupted while waiting
538 */
539 public void testAwaitAdvanceBeforeInterrupt() {
540 final Phaser phaser = new Phaser();
541 assertEquals(0, phaser.register());
542 final CountDownLatch pleaseArrive = new CountDownLatch(1);
543
544 Thread t = newStartedThread(new CheckedRunnable() {
545 public void realRun() {
546 assertEquals(0, phaser.register());
547 assertEquals(0, phaser.arrive());
548 assertFalse(Thread.currentThread().isInterrupted());
549 pleaseArrive.countDown();
550 assertEquals(1, phaser.awaitAdvance(0));
551 assertTrue(Thread.interrupted());
552 }});
553
554 await(pleaseArrive);
555 assertThreadBlocks(t, Thread.State.WAITING);
556 t.interrupt();
557 assertEquals(0, phaser.arrive());
558 awaitTermination(t);
559
560 Thread.currentThread().interrupt();
561 assertEquals(1, phaser.awaitAdvance(0));
562 assertTrue(Thread.interrupted());
563 }
564
565 /**
566 * arriveAndAwaitAdvance continues waiting if interrupted before waiting
567 */
568 public void testArriveAndAwaitAdvanceAfterInterrupt() {
569 final Phaser phaser = new Phaser();
570 assertEquals(0, phaser.register());
571 final CountDownLatch pleaseArrive = new CountDownLatch(1);
572
573 Thread t = newStartedThread(new CheckedRunnable() {
574 public void realRun() {
575 Thread.currentThread().interrupt();
576 assertEquals(0, phaser.register());
577 pleaseArrive.countDown();
578 assertTrue(Thread.currentThread().isInterrupted());
579 assertEquals(1, phaser.arriveAndAwaitAdvance());
580 assertTrue(Thread.interrupted());
581 }});
582
583 await(pleaseArrive);
584 assertThreadBlocks(t, Thread.State.WAITING);
585 Thread.currentThread().interrupt();
586 assertEquals(1, phaser.arriveAndAwaitAdvance());
587 assertTrue(Thread.interrupted());
588 awaitTermination(t);
589 }
590
591 /**
592 * arriveAndAwaitAdvance continues waiting if interrupted while waiting
593 */
594 public void testArriveAndAwaitAdvanceBeforeInterrupt() {
595 final Phaser phaser = new Phaser();
596 assertEquals(0, phaser.register());
597 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
598
599 Thread t = newStartedThread(new CheckedRunnable() {
600 public void realRun() {
601 assertEquals(0, phaser.register());
602 assertFalse(Thread.currentThread().isInterrupted());
603 pleaseInterrupt.countDown();
604 assertEquals(1, phaser.arriveAndAwaitAdvance());
605 assertTrue(Thread.interrupted());
606 }});
607
608 await(pleaseInterrupt);
609 assertThreadBlocks(t, Thread.State.WAITING);
610 t.interrupt();
611 Thread.currentThread().interrupt();
612 assertEquals(1, phaser.arriveAndAwaitAdvance());
613 assertTrue(Thread.interrupted());
614 awaitTermination(t);
615 }
616
617 /**
618 * awaitAdvance atomically waits for all parties within the same phase to
619 * complete before continuing
620 */
621 public void testAwaitAdvance4() {
622 final Phaser phaser = new Phaser(4);
623 final AtomicInteger count = new AtomicInteger(0);
624 List<Thread> threads = new ArrayList<>();
625 for (int i = 0; i < 4; i++)
626 threads.add(newStartedThread(new CheckedRunnable() {
627 public void realRun() {
628 for (int k = 0; k < 3; k++) {
629 assertEquals(2 * k + 1, phaser.arriveAndAwaitAdvance());
630 count.incrementAndGet();
631 assertEquals(2 * k + 1, phaser.arrive());
632 assertEquals(2 * k + 2, phaser.awaitAdvance(2 * k + 1));
633 assertEquals(4 * (k + 1), count.get());
634 }}}));
635
636 for (Thread thread : threads)
637 awaitTermination(thread);
638 }
639
640 /**
641 * awaitAdvance returns the current phase
642 */
643 public void testAwaitAdvance5() {
644 final Phaser phaser = new Phaser(1);
645 assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
646 assertEquals(1, phaser.getPhase());
647 assertEquals(1, phaser.register());
648 List<Thread> threads = new ArrayList<>();
649 for (int i = 0; i < 8; i++) {
650 final CountDownLatch latch = new CountDownLatch(1);
651 final boolean goesFirst = ((i & 1) == 0);
652 threads.add(newStartedThread(new CheckedRunnable() {
653 public void realRun() {
654 if (goesFirst)
655 latch.countDown();
656 else
657 await(latch);
658 phaser.arrive();
659 }}));
660 if (goesFirst)
661 await(latch);
662 else
663 latch.countDown();
664 assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive()));
665 assertEquals(i + 2, phaser.getPhase());
666 }
667 for (Thread thread : threads)
668 awaitTermination(thread);
669 }
670
671 /**
672 * awaitAdvance returns the current phase in child phasers
673 */
674 public void testAwaitAdvanceTieredPhaser() throws Exception {
675 final Phaser parent = new Phaser();
676 final List<Phaser> zeroPartyChildren = new ArrayList<>(3);
677 final List<Phaser> onePartyChildren = new ArrayList<>(3);
678 for (int i = 0; i < 3; i++) {
679 zeroPartyChildren.add(new Phaser(parent, 0));
680 onePartyChildren.add(new Phaser(parent, 1));
681 }
682 final List<Phaser> phasers = new ArrayList<>();
683 phasers.addAll(zeroPartyChildren);
684 phasers.addAll(onePartyChildren);
685 phasers.add(parent);
686 for (Phaser phaser : phasers) {
687 assertEquals(-42, phaser.awaitAdvance(-42));
688 assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
689 assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, MEDIUM_DELAY_MS, MILLISECONDS));
690 }
691
692 for (Phaser child : onePartyChildren)
693 assertEquals(0, child.arrive());
694 for (Phaser phaser : phasers) {
695 assertEquals(-42, phaser.awaitAdvance(-42));
696 assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
697 assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, MEDIUM_DELAY_MS, MILLISECONDS));
698 assertEquals(1, phaser.awaitAdvance(0));
699 assertEquals(1, phaser.awaitAdvanceInterruptibly(0));
700 assertEquals(1, phaser.awaitAdvanceInterruptibly(0, MEDIUM_DELAY_MS, MILLISECONDS));
701 }
702
703 for (Phaser child : onePartyChildren)
704 assertEquals(1, child.arrive());
705 for (Phaser phaser : phasers) {
706 assertEquals(-42, phaser.awaitAdvance(-42));
707 assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
708 assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, MEDIUM_DELAY_MS, MILLISECONDS));
709 assertEquals(2, phaser.awaitAdvance(0));
710 assertEquals(2, phaser.awaitAdvanceInterruptibly(0));
711 assertEquals(2, phaser.awaitAdvanceInterruptibly(0, MEDIUM_DELAY_MS, MILLISECONDS));
712 assertEquals(2, phaser.awaitAdvance(1));
713 assertEquals(2, phaser.awaitAdvanceInterruptibly(1));
714 assertEquals(2, phaser.awaitAdvanceInterruptibly(1, MEDIUM_DELAY_MS, MILLISECONDS));
715 }
716 }
717
718 /**
719 * awaitAdvance returns when the phaser is externally terminated
720 */
721 public void testAwaitAdvance6() {
722 final Phaser phaser = new Phaser(3);
723 final CountDownLatch pleaseForceTermination = new CountDownLatch(2);
724 final List<Thread> threads = new ArrayList<>();
725 for (int i = 0; i < 2; i++) {
726 Runnable r = new CheckedRunnable() {
727 public void realRun() {
728 assertEquals(0, phaser.arrive());
729 pleaseForceTermination.countDown();
730 assertTrue(phaser.awaitAdvance(0) < 0);
731 assertTrue(phaser.isTerminated());
732 assertTrue(phaser.getPhase() < 0);
733 assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
734 assertEquals(3, phaser.getRegisteredParties());
735 }};
736 threads.add(newStartedThread(r));
737 }
738 await(pleaseForceTermination);
739 phaser.forceTermination();
740 assertTrue(phaser.isTerminated());
741 assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
742 for (Thread thread : threads)
743 awaitTermination(thread);
744 assertEquals(3, phaser.getRegisteredParties());
745 }
746
747 /**
748 * arriveAndAwaitAdvance throws IllegalStateException with no
749 * unarrived parties
750 */
751 public void testArriveAndAwaitAdvance1() {
752 Phaser phaser = new Phaser();
753 try {
754 phaser.arriveAndAwaitAdvance();
755 shouldThrow();
756 } catch (IllegalStateException success) {}
757 }
758
759 /**
760 * arriveAndAwaitAdvance waits for all threads to arrive, the
761 * number of arrived parties is the same number that is accounted
762 * for when the main thread awaitsAdvance
763 */
764 public void testArriveAndAwaitAdvance3() {
765 final Phaser phaser = new Phaser(1);
766 final int THREADS = 3;
767 final CountDownLatch pleaseArrive = new CountDownLatch(THREADS);
768 final List<Thread> threads = new ArrayList<>();
769 for (int i = 0; i < THREADS; i++)
770 threads.add(newStartedThread(new CheckedRunnable() {
771 public void realRun() {
772 assertEquals(0, phaser.register());
773 pleaseArrive.countDown();
774 assertEquals(1, phaser.arriveAndAwaitAdvance());
775 }}));
776
777 await(pleaseArrive);
778 long startTime = System.nanoTime();
779 while (phaser.getArrivedParties() < THREADS)
780 Thread.yield();
781 assertEquals(THREADS, phaser.getArrivedParties());
782 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
783 for (Thread thread : threads)
784 assertThreadBlocks(thread, Thread.State.WAITING);
785 for (Thread thread : threads)
786 assertTrue(thread.isAlive());
787 assertState(phaser, 0, THREADS + 1, 1);
788 phaser.arriveAndAwaitAdvance();
789 for (Thread thread : threads)
790 awaitTermination(thread);
791 assertState(phaser, 1, THREADS + 1, THREADS + 1);
792 }
793
794 }