| 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 John Vint |
| 6 |
|
*/ |
| 7 |
|
|
| 8 |
+ |
import junit.framework.*; |
| 9 |
|
import java.util.ArrayList; |
| 10 |
|
import java.util.List; |
| 11 |
< |
import java.util.concurrent.atomic.AtomicInteger; |
| 12 |
< |
import java.util.concurrent.atomic.AtomicBoolean; |
| 13 |
< |
import java.util.concurrent.*; |
| 11 |
> |
import java.util.concurrent.Phaser; |
| 12 |
> |
import java.util.concurrent.CountDownLatch; |
| 13 |
> |
import java.util.concurrent.TimeoutException; |
| 14 |
|
import static java.util.concurrent.TimeUnit.MILLISECONDS; |
| 15 |
|
import static java.util.concurrent.TimeUnit.NANOSECONDS; |
| 16 |
< |
import junit.framework.Test; |
| 17 |
< |
import junit.framework.TestSuite; |
| 16 |
> |
import java.util.concurrent.atomic.AtomicBoolean; |
| 17 |
> |
import java.util.concurrent.atomic.AtomicInteger; |
| 18 |
|
|
| 19 |
|
public class PhaserTest extends JSR166TestCase { |
| 20 |
|
|
| 28 |
|
|
| 29 |
|
private static final int maxParties = 65535; |
| 30 |
|
|
| 31 |
< |
/** Checks state of phaser. */ |
| 31 |
> |
/** Checks state of unterminated phaser. */ |
| 32 |
|
protected void assertState(Phaser phaser, |
| 33 |
|
int phase, int parties, int unarrived) { |
| 34 |
|
assertEquals(phase, phaser.getPhase()); |
| 35 |
|
assertEquals(parties, phaser.getRegisteredParties()); |
| 36 |
|
assertEquals(unarrived, phaser.getUnarrivedParties()); |
| 37 |
|
assertEquals(parties - unarrived, phaser.getArrivedParties()); |
| 38 |
< |
assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated()); |
| 38 |
> |
assertFalse(phaser.isTerminated()); |
| 39 |
|
} |
| 40 |
|
|
| 41 |
|
/** Checks state of terminated phaser. */ |
| 42 |
< |
protected void assertTerminated(Phaser phaser, |
| 42 |
< |
int maxPhase, int parties, int unarrived) { |
| 42 |
> |
protected void assertTerminated(Phaser phaser, int maxPhase, int parties) { |
| 43 |
|
assertTrue(phaser.isTerminated()); |
| 44 |
|
int expectedPhase = maxPhase + Integer.MIN_VALUE; |
| 45 |
|
assertEquals(expectedPhase, phaser.getPhase()); |
| 50 |
|
} |
| 51 |
|
|
| 52 |
|
protected void assertTerminated(Phaser phaser, int maxPhase) { |
| 53 |
< |
assertTerminated(phaser, maxPhase, 0, 0); |
| 53 |
> |
assertTerminated(phaser, maxPhase, 0); |
| 54 |
|
} |
| 55 |
|
|
| 56 |
|
/** |
| 159 |
|
phaser.bulkRegister(Integer.MAX_VALUE); |
| 160 |
|
shouldThrow(); |
| 161 |
|
} catch (IllegalStateException success) {} |
| 162 |
+ |
|
| 163 |
+ |
assertEquals(0, phaser.bulkRegister(0)); |
| 164 |
+ |
assertState(phaser, 0, maxParties, maxParties); |
| 165 |
|
} |
| 166 |
|
|
| 167 |
|
/** |
| 205 |
|
*/ |
| 206 |
|
public void testBulkRegister2() { |
| 207 |
|
Phaser phaser = new Phaser(); |
| 208 |
+ |
assertEquals(0, phaser.bulkRegister(0)); |
| 209 |
+ |
assertState(phaser, 0, 0, 0); |
| 210 |
|
assertEquals(0, phaser.bulkRegister(20)); |
| 211 |
|
assertState(phaser, 0, 20, 20); |
| 212 |
|
} |
| 255 |
|
/** |
| 256 |
|
* arriveAndDeregister does not wait for others to arrive at barrier |
| 257 |
|
*/ |
| 258 |
< |
public void testArriveAndDeregister() throws InterruptedException { |
| 258 |
> |
public void testArriveAndDeregister() { |
| 259 |
|
final Phaser phaser = new Phaser(1); |
| 260 |
|
for (int i = 0; i < 10; i++) { |
| 261 |
|
assertState(phaser, 0, 1, 1); |
| 271 |
|
/** |
| 272 |
|
* arriveAndDeregister does not wait for others to arrive at barrier |
| 273 |
|
*/ |
| 274 |
< |
public void testArrive2() throws InterruptedException { |
| 274 |
> |
public void testArrive2() { |
| 275 |
|
final Phaser phaser = new Phaser(); |
| 276 |
|
assertEquals(0, phaser.register()); |
| 277 |
|
List<Thread> threads = new ArrayList<Thread>(); |
| 278 |
|
for (int i = 0; i < 10; i++) { |
| 279 |
|
assertEquals(0, phaser.register()); |
| 280 |
|
threads.add(newStartedThread(new CheckedRunnable() { |
| 281 |
< |
public void realRun() throws InterruptedException { |
| 281 |
> |
public void realRun() { |
| 282 |
|
assertEquals(0, phaser.arriveAndDeregister()); |
| 283 |
|
}})); |
| 284 |
|
} |
| 285 |
|
|
| 286 |
|
for (Thread thread : threads) |
| 287 |
< |
awaitTermination(thread, LONG_DELAY_MS); |
| 287 |
> |
awaitTermination(thread); |
| 288 |
|
assertState(phaser, 0, 1, 1); |
| 289 |
|
assertEquals(0, phaser.arrive()); |
| 290 |
|
assertState(phaser, 1, 1, 1); |
| 296 |
|
public void testArrive3() { |
| 297 |
|
Phaser phaser = new Phaser(1); |
| 298 |
|
phaser.forceTermination(); |
| 299 |
< |
assertTerminated(phaser, 0, 1, 1); |
| 299 |
> |
assertTerminated(phaser, 0, 1); |
| 300 |
|
assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE); |
| 301 |
|
assertTrue(phaser.arrive() < 0); |
| 302 |
|
assertTrue(phaser.register() < 0); |
| 388 |
|
* arriveAndDeregister returns the phase in which it leaves the |
| 389 |
|
* phaser in after deregistration |
| 390 |
|
*/ |
| 391 |
< |
public void testArriveAndDeregister6() throws InterruptedException { |
| 391 |
> |
public void testArriveAndDeregister6() { |
| 392 |
|
final Phaser phaser = new Phaser(2); |
| 393 |
|
Thread t = newStartedThread(new CheckedRunnable() { |
| 394 |
|
public void realRun() { |
| 400 |
|
assertState(phaser, 1, 1, 1); |
| 401 |
|
assertEquals(1, phaser.arriveAndDeregister()); |
| 402 |
|
assertTerminated(phaser, 2); |
| 403 |
< |
awaitTermination(t, SHORT_DELAY_MS); |
| 403 |
> |
awaitTermination(t); |
| 404 |
|
} |
| 405 |
|
|
| 406 |
|
/** |
| 423 |
|
} |
| 424 |
|
|
| 425 |
|
/** |
| 426 |
+ |
* awaitAdvanceInterruptibly blocks interruptibly |
| 427 |
+ |
*/ |
| 428 |
+ |
public void testAwaitAdvanceInterruptibly_interruptible() throws InterruptedException { |
| 429 |
+ |
final Phaser phaser = new Phaser(1); |
| 430 |
+ |
final CountDownLatch pleaseInterrupt = new CountDownLatch(2); |
| 431 |
+ |
|
| 432 |
+ |
Thread t1 = newStartedThread(new CheckedRunnable() { |
| 433 |
+ |
public void realRun() { |
| 434 |
+ |
Thread.currentThread().interrupt(); |
| 435 |
+ |
try { |
| 436 |
+ |
phaser.awaitAdvanceInterruptibly(0); |
| 437 |
+ |
shouldThrow(); |
| 438 |
+ |
} catch (InterruptedException success) {} |
| 439 |
+ |
assertFalse(Thread.interrupted()); |
| 440 |
+ |
|
| 441 |
+ |
pleaseInterrupt.countDown(); |
| 442 |
+ |
try { |
| 443 |
+ |
phaser.awaitAdvanceInterruptibly(0); |
| 444 |
+ |
shouldThrow(); |
| 445 |
+ |
} catch (InterruptedException success) {} |
| 446 |
+ |
assertFalse(Thread.interrupted()); |
| 447 |
+ |
}}); |
| 448 |
+ |
|
| 449 |
+ |
Thread t2 = newStartedThread(new CheckedRunnable() { |
| 450 |
+ |
public void realRun() throws TimeoutException { |
| 451 |
+ |
Thread.currentThread().interrupt(); |
| 452 |
+ |
try { |
| 453 |
+ |
phaser.awaitAdvanceInterruptibly(0, 2*LONG_DELAY_MS, MILLISECONDS); |
| 454 |
+ |
shouldThrow(); |
| 455 |
+ |
} catch (InterruptedException success) {} |
| 456 |
+ |
assertFalse(Thread.interrupted()); |
| 457 |
+ |
|
| 458 |
+ |
pleaseInterrupt.countDown(); |
| 459 |
+ |
try { |
| 460 |
+ |
phaser.awaitAdvanceInterruptibly(0, 2*LONG_DELAY_MS, MILLISECONDS); |
| 461 |
+ |
shouldThrow(); |
| 462 |
+ |
} catch (InterruptedException success) {} |
| 463 |
+ |
assertFalse(Thread.interrupted()); |
| 464 |
+ |
}}); |
| 465 |
+ |
|
| 466 |
+ |
await(pleaseInterrupt); |
| 467 |
+ |
assertState(phaser, 0, 1, 1); |
| 468 |
+ |
assertThreadsStayAlive(t1, t2); |
| 469 |
+ |
t1.interrupt(); |
| 470 |
+ |
t2.interrupt(); |
| 471 |
+ |
awaitTermination(t1); |
| 472 |
+ |
awaitTermination(t2); |
| 473 |
+ |
assertState(phaser, 0, 1, 1); |
| 474 |
+ |
assertEquals(0, phaser.arrive()); |
| 475 |
+ |
assertState(phaser, 1, 1, 1); |
| 476 |
+ |
} |
| 477 |
+ |
|
| 478 |
+ |
/** |
| 479 |
|
* awaitAdvance continues waiting if interrupted before waiting |
| 480 |
|
*/ |
| 481 |
< |
public void testAwaitAdvanceAfterInterrupt() throws InterruptedException { |
| 481 |
> |
public void testAwaitAdvanceAfterInterrupt() { |
| 482 |
|
final Phaser phaser = new Phaser(); |
| 483 |
|
assertEquals(0, phaser.register()); |
| 484 |
< |
final CountDownLatch threadStarted = new CountDownLatch(1); |
| 484 |
> |
final CountDownLatch pleaseArrive = new CountDownLatch(1); |
| 485 |
|
|
| 486 |
|
Thread t = newStartedThread(new CheckedRunnable() { |
| 487 |
< |
public void realRun() throws InterruptedException { |
| 487 |
> |
public void realRun() { |
| 488 |
|
Thread.currentThread().interrupt(); |
| 489 |
|
assertEquals(0, phaser.register()); |
| 490 |
|
assertEquals(0, phaser.arrive()); |
| 491 |
< |
threadStarted.countDown(); |
| 491 |
> |
pleaseArrive.countDown(); |
| 492 |
|
assertTrue(Thread.currentThread().isInterrupted()); |
| 493 |
|
assertEquals(1, phaser.awaitAdvance(0)); |
| 494 |
< |
assertTrue(Thread.currentThread().isInterrupted()); |
| 494 |
> |
assertTrue(Thread.interrupted()); |
| 495 |
|
}}); |
| 496 |
|
|
| 497 |
< |
assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); |
| 498 |
< |
waitForThreadToEnterWaitState(t, SMALL_DELAY_MS); |
| 497 |
> |
await(pleaseArrive); |
| 498 |
> |
waitForThreadToEnterWaitState(t, SHORT_DELAY_MS); |
| 499 |
|
assertEquals(0, phaser.arrive()); |
| 500 |
< |
awaitTermination(t, SMALL_DELAY_MS); |
| 500 |
> |
awaitTermination(t); |
| 501 |
|
|
| 502 |
|
Thread.currentThread().interrupt(); |
| 503 |
|
assertEquals(1, phaser.awaitAdvance(0)); |
| 505 |
|
} |
| 506 |
|
|
| 507 |
|
/** |
| 508 |
< |
* awaitAdvance continues waiting if interrupted while waiting |
| 508 |
> |
* awaitAdvance continues waiting if interrupted while waiting |
| 509 |
|
*/ |
| 510 |
< |
public void testAwaitAdvanceBeforeInterrupt() throws InterruptedException { |
| 510 |
> |
public void testAwaitAdvanceBeforeInterrupt() { |
| 511 |
|
final Phaser phaser = new Phaser(); |
| 512 |
|
assertEquals(0, phaser.register()); |
| 513 |
< |
final CountDownLatch threadStarted = new CountDownLatch(1); |
| 513 |
> |
final CountDownLatch pleaseArrive = new CountDownLatch(1); |
| 514 |
|
|
| 515 |
|
Thread t = newStartedThread(new CheckedRunnable() { |
| 516 |
< |
public void realRun() throws InterruptedException { |
| 516 |
> |
public void realRun() { |
| 517 |
|
assertEquals(0, phaser.register()); |
| 518 |
|
assertEquals(0, phaser.arrive()); |
| 461 |
– |
threadStarted.countDown(); |
| 519 |
|
assertFalse(Thread.currentThread().isInterrupted()); |
| 520 |
+ |
pleaseArrive.countDown(); |
| 521 |
|
assertEquals(1, phaser.awaitAdvance(0)); |
| 522 |
< |
assertTrue(Thread.currentThread().isInterrupted()); |
| 522 |
> |
assertTrue(Thread.interrupted()); |
| 523 |
|
}}); |
| 524 |
|
|
| 525 |
< |
assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); |
| 526 |
< |
waitForThreadToEnterWaitState(t, SMALL_DELAY_MS); |
| 525 |
> |
await(pleaseArrive); |
| 526 |
> |
waitForThreadToEnterWaitState(t, SHORT_DELAY_MS); |
| 527 |
|
t.interrupt(); |
| 528 |
|
assertEquals(0, phaser.arrive()); |
| 529 |
< |
awaitTermination(t, SMALL_DELAY_MS); |
| 529 |
> |
awaitTermination(t); |
| 530 |
|
|
| 531 |
|
Thread.currentThread().interrupt(); |
| 532 |
|
assertEquals(1, phaser.awaitAdvance(0)); |
| 536 |
|
/** |
| 537 |
|
* arriveAndAwaitAdvance continues waiting if interrupted before waiting |
| 538 |
|
*/ |
| 539 |
< |
public void testArriveAndAwaitAdvanceAfterInterrupt() |
| 482 |
< |
throws InterruptedException { |
| 539 |
> |
public void testArriveAndAwaitAdvanceAfterInterrupt() { |
| 540 |
|
final Phaser phaser = new Phaser(); |
| 541 |
|
assertEquals(0, phaser.register()); |
| 542 |
< |
final CountDownLatch threadStarted = new CountDownLatch(1); |
| 542 |
> |
final CountDownLatch pleaseInterrupt = new CountDownLatch(1); |
| 543 |
|
|
| 544 |
|
Thread t = newStartedThread(new CheckedRunnable() { |
| 545 |
< |
public void realRun() throws InterruptedException { |
| 545 |
> |
public void realRun() { |
| 546 |
|
Thread.currentThread().interrupt(); |
| 547 |
|
assertEquals(0, phaser.register()); |
| 548 |
< |
threadStarted.countDown(); |
| 548 |
> |
pleaseInterrupt.countDown(); |
| 549 |
|
assertTrue(Thread.currentThread().isInterrupted()); |
| 550 |
|
assertEquals(1, phaser.arriveAndAwaitAdvance()); |
| 551 |
|
assertTrue(Thread.currentThread().isInterrupted()); |
| 552 |
|
}}); |
| 553 |
|
|
| 554 |
< |
assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); |
| 555 |
< |
waitForThreadToEnterWaitState(t, SMALL_DELAY_MS); |
| 554 |
> |
await(pleaseInterrupt); |
| 555 |
> |
waitForThreadToEnterWaitState(t, SHORT_DELAY_MS); |
| 556 |
|
Thread.currentThread().interrupt(); |
| 557 |
|
assertEquals(1, phaser.arriveAndAwaitAdvance()); |
| 558 |
|
assertTrue(Thread.interrupted()); |
| 559 |
< |
awaitTermination(t, SMALL_DELAY_MS); |
| 559 |
> |
awaitTermination(t); |
| 560 |
|
} |
| 561 |
|
|
| 562 |
|
/** |
| 563 |
|
* arriveAndAwaitAdvance continues waiting if interrupted while waiting |
| 564 |
|
*/ |
| 565 |
< |
public void testArriveAndAwaitAdvanceBeforeInterrupt() |
| 509 |
< |
throws InterruptedException { |
| 565 |
> |
public void testArriveAndAwaitAdvanceBeforeInterrupt() { |
| 566 |
|
final Phaser phaser = new Phaser(); |
| 567 |
|
assertEquals(0, phaser.register()); |
| 568 |
< |
final CountDownLatch threadStarted = new CountDownLatch(1); |
| 568 |
> |
final CountDownLatch pleaseInterrupt = new CountDownLatch(1); |
| 569 |
|
|
| 570 |
|
Thread t = newStartedThread(new CheckedRunnable() { |
| 571 |
< |
public void realRun() throws InterruptedException { |
| 571 |
> |
public void realRun() { |
| 572 |
|
assertEquals(0, phaser.register()); |
| 517 |
– |
threadStarted.countDown(); |
| 573 |
|
assertFalse(Thread.currentThread().isInterrupted()); |
| 574 |
+ |
pleaseInterrupt.countDown(); |
| 575 |
|
assertEquals(1, phaser.arriveAndAwaitAdvance()); |
| 576 |
|
assertTrue(Thread.currentThread().isInterrupted()); |
| 577 |
|
}}); |
| 578 |
|
|
| 579 |
< |
assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); |
| 580 |
< |
waitForThreadToEnterWaitState(t, SMALL_DELAY_MS); |
| 579 |
> |
await(pleaseInterrupt); |
| 580 |
> |
waitForThreadToEnterWaitState(t, SHORT_DELAY_MS); |
| 581 |
|
t.interrupt(); |
| 582 |
|
Thread.currentThread().interrupt(); |
| 583 |
|
assertEquals(1, phaser.arriveAndAwaitAdvance()); |
| 584 |
|
assertTrue(Thread.interrupted()); |
| 585 |
< |
awaitTermination(t, SMALL_DELAY_MS); |
| 585 |
> |
awaitTermination(t); |
| 586 |
|
} |
| 587 |
|
|
| 588 |
|
/** |
| 589 |
|
* awaitAdvance atomically waits for all parties within the same phase to |
| 590 |
|
* complete before continuing |
| 591 |
|
*/ |
| 592 |
< |
public void testAwaitAdvance4() throws InterruptedException { |
| 592 |
> |
public void testAwaitAdvance4() { |
| 593 |
|
final Phaser phaser = new Phaser(4); |
| 594 |
|
final AtomicInteger count = new AtomicInteger(0); |
| 595 |
|
List<Thread> threads = new ArrayList<Thread>(); |
| 605 |
|
}}})); |
| 606 |
|
|
| 607 |
|
for (Thread thread : threads) |
| 608 |
< |
awaitTermination(thread, MEDIUM_DELAY_MS); |
| 608 |
> |
awaitTermination(thread); |
| 609 |
|
} |
| 610 |
|
|
| 611 |
|
/** |
| 612 |
|
* awaitAdvance returns the current phase |
| 613 |
|
*/ |
| 614 |
< |
public void testAwaitAdvance5() throws InterruptedException { |
| 614 |
> |
public void testAwaitAdvance5() { |
| 615 |
|
final Phaser phaser = new Phaser(1); |
| 616 |
|
assertEquals(1, phaser.awaitAdvance(phaser.arrive())); |
| 617 |
|
assertEquals(1, phaser.getPhase()); |
| 621 |
|
final CountDownLatch latch = new CountDownLatch(1); |
| 622 |
|
final boolean goesFirst = ((i & 1) == 0); |
| 623 |
|
threads.add(newStartedThread(new CheckedRunnable() { |
| 624 |
< |
public void realRun() throws InterruptedException { |
| 624 |
> |
public void realRun() { |
| 625 |
|
if (goesFirst) |
| 626 |
|
latch.countDown(); |
| 627 |
|
else |
| 628 |
< |
assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS)); |
| 628 |
> |
await(latch); |
| 629 |
|
phaser.arrive(); |
| 630 |
|
}})); |
| 631 |
|
if (goesFirst) |
| 632 |
< |
assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS)); |
| 632 |
> |
await(latch); |
| 633 |
|
else |
| 634 |
|
latch.countDown(); |
| 635 |
|
assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive())); |
| 636 |
|
assertEquals(i + 2, phaser.getPhase()); |
| 637 |
|
} |
| 638 |
|
for (Thread thread : threads) |
| 639 |
< |
awaitTermination(thread, SMALL_DELAY_MS); |
| 639 |
> |
awaitTermination(thread); |
| 640 |
> |
} |
| 641 |
> |
|
| 642 |
> |
/** |
| 643 |
> |
* awaitAdvance returns the current phase in child phasers |
| 644 |
> |
*/ |
| 645 |
> |
public void testAwaitAdvanceTieredPhaser() throws Exception { |
| 646 |
> |
final Phaser parent = new Phaser(); |
| 647 |
> |
final List<Phaser> zeroPartyChildren = new ArrayList<Phaser>(3); |
| 648 |
> |
final List<Phaser> onePartyChildren = new ArrayList<Phaser>(3); |
| 649 |
> |
for (int i = 0; i < 3; i++) { |
| 650 |
> |
zeroPartyChildren.add(new Phaser(parent, 0)); |
| 651 |
> |
onePartyChildren.add(new Phaser(parent, 1)); |
| 652 |
> |
} |
| 653 |
> |
final List<Phaser> phasers = new ArrayList<Phaser>(); |
| 654 |
> |
phasers.addAll(zeroPartyChildren); |
| 655 |
> |
phasers.addAll(onePartyChildren); |
| 656 |
> |
phasers.add(parent); |
| 657 |
> |
for (Phaser phaser : phasers) { |
| 658 |
> |
assertEquals(-42, phaser.awaitAdvance(-42)); |
| 659 |
> |
assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42)); |
| 660 |
> |
assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS)); |
| 661 |
> |
} |
| 662 |
> |
|
| 663 |
> |
for (Phaser child : onePartyChildren) |
| 664 |
> |
assertEquals(0, child.arrive()); |
| 665 |
> |
for (Phaser phaser : phasers) { |
| 666 |
> |
assertEquals(-42, phaser.awaitAdvance(-42)); |
| 667 |
> |
assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42)); |
| 668 |
> |
assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS)); |
| 669 |
> |
assertEquals(1, phaser.awaitAdvance(0)); |
| 670 |
> |
assertEquals(1, phaser.awaitAdvanceInterruptibly(0)); |
| 671 |
> |
assertEquals(1, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS)); |
| 672 |
> |
} |
| 673 |
> |
|
| 674 |
> |
for (Phaser child : onePartyChildren) |
| 675 |
> |
assertEquals(1, child.arrive()); |
| 676 |
> |
for (Phaser phaser : phasers) { |
| 677 |
> |
assertEquals(-42, phaser.awaitAdvance(-42)); |
| 678 |
> |
assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42)); |
| 679 |
> |
assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS)); |
| 680 |
> |
assertEquals(2, phaser.awaitAdvance(0)); |
| 681 |
> |
assertEquals(2, phaser.awaitAdvanceInterruptibly(0)); |
| 682 |
> |
assertEquals(2, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS)); |
| 683 |
> |
assertEquals(2, phaser.awaitAdvance(1)); |
| 684 |
> |
assertEquals(2, phaser.awaitAdvanceInterruptibly(1)); |
| 685 |
> |
assertEquals(2, phaser.awaitAdvanceInterruptibly(1, SMALL_DELAY_MS, MILLISECONDS)); |
| 686 |
> |
} |
| 687 |
|
} |
| 688 |
|
|
| 689 |
|
/** |
| 690 |
|
* awaitAdvance returns when the phaser is externally terminated |
| 691 |
|
*/ |
| 692 |
< |
public void testAwaitAdvance6() throws InterruptedException { |
| 692 |
> |
public void testAwaitAdvance6() { |
| 693 |
|
final Phaser phaser = new Phaser(3); |
| 694 |
< |
final CountDownLatch threadsStarted = new CountDownLatch(2); |
| 694 |
> |
final CountDownLatch pleaseForceTermination = new CountDownLatch(2); |
| 695 |
|
final List<Thread> threads = new ArrayList<Thread>(); |
| 696 |
|
for (int i = 0; i < 2; i++) { |
| 697 |
|
Runnable r = new CheckedRunnable() { |
| 698 |
|
public void realRun() { |
| 699 |
|
assertEquals(0, phaser.arrive()); |
| 700 |
< |
threadsStarted.countDown(); |
| 700 |
> |
pleaseForceTermination.countDown(); |
| 701 |
|
assertTrue(phaser.awaitAdvance(0) < 0); |
| 702 |
|
assertTrue(phaser.isTerminated()); |
| 703 |
|
assertTrue(phaser.getPhase() < 0); |
| 706 |
|
}}; |
| 707 |
|
threads.add(newStartedThread(r)); |
| 708 |
|
} |
| 709 |
< |
threadsStarted.await(); |
| 709 |
> |
await(pleaseForceTermination); |
| 710 |
|
phaser.forceTermination(); |
| 711 |
|
assertTrue(phaser.isTerminated()); |
| 712 |
|
assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE); |
| 713 |
|
for (Thread thread : threads) |
| 714 |
< |
awaitTermination(thread, SMALL_DELAY_MS); |
| 714 |
> |
awaitTermination(thread); |
| 715 |
|
assertEquals(3, phaser.getRegisteredParties()); |
| 716 |
|
} |
| 717 |
|
|
| 732 |
|
* number of arrived parties is the same number that is accounted |
| 733 |
|
* for when the main thread awaitsAdvance |
| 734 |
|
*/ |
| 735 |
< |
public void testArriveAndAwaitAdvance3() throws InterruptedException { |
| 735 |
> |
public void testArriveAndAwaitAdvance3() { |
| 736 |
|
final Phaser phaser = new Phaser(1); |
| 737 |
|
final int THREADS = 3; |
| 738 |
< |
final CountDownLatch threadsStarted = new CountDownLatch(THREADS); |
| 738 |
> |
final CountDownLatch pleaseArrive = new CountDownLatch(THREADS); |
| 739 |
|
final List<Thread> threads = new ArrayList<Thread>(); |
| 740 |
|
for (int i = 0; i < THREADS; i++) |
| 741 |
|
threads.add(newStartedThread(new CheckedRunnable() { |
| 742 |
< |
public void realRun() throws InterruptedException { |
| 742 |
> |
public void realRun() { |
| 743 |
|
assertEquals(0, phaser.register()); |
| 744 |
< |
threadsStarted.countDown(); |
| 744 |
> |
pleaseArrive.countDown(); |
| 745 |
|
assertEquals(1, phaser.arriveAndAwaitAdvance()); |
| 746 |
|
}})); |
| 747 |
|
|
| 748 |
< |
assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS)); |
| 749 |
< |
long t0 = System.nanoTime(); |
| 748 |
> |
await(pleaseArrive); |
| 749 |
> |
long startTime = System.nanoTime(); |
| 750 |
|
while (phaser.getArrivedParties() < THREADS) |
| 751 |
|
Thread.yield(); |
| 752 |
|
assertEquals(THREADS, phaser.getArrivedParties()); |
| 753 |
< |
assertTrue(NANOSECONDS.toMillis(System.nanoTime() - t0) < SMALL_DELAY_MS); |
| 753 |
> |
assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); |
| 754 |
> |
for (Thread thread : threads) |
| 755 |
> |
waitForThreadToEnterWaitState(thread, SHORT_DELAY_MS); |
| 756 |
|
for (Thread thread : threads) |
| 757 |
|
assertTrue(thread.isAlive()); |
| 758 |
|
assertState(phaser, 0, THREADS + 1, 1); |
| 759 |
|
phaser.arriveAndAwaitAdvance(); |
| 760 |
|
for (Thread thread : threads) |
| 761 |
< |
awaitTermination(thread, SMALL_DELAY_MS); |
| 761 |
> |
awaitTermination(thread); |
| 762 |
|
assertState(phaser, 1, THREADS + 1, THREADS + 1); |
| 763 |
|
} |
| 764 |
|
|
