ViewVC Help

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

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

Comparing jsr166/src/test/tck/PhaserTest.java (file contents):
Revision 1.24 by dl, Mon Nov 29 15:47:29 2010 UTC vs.
Revision 1.38 by jsr166, Wed Dec 31 16:44:02 2014 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include 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;
15	<	import junit.framework.Test;
16	<	import junit.framework.TestSuite;
15	>	import java.util.concurrent.atomic.AtomicInteger;
16
17		public class PhaserTest extends JSR166TestCase {
18
#	Line 27 | Line 26 | public class PhaserTest extends JSR166Te
26
27		private static final int maxParties = 65535;
28
29	<	/** Checks state of phaser. */
29	>	/** Checks state of unterminated phaser. */
30		protected void assertState(Phaser phaser,
31		int phase, int parties, int unarrived) {
32		assertEquals(phase, phaser.getPhase());
33		assertEquals(parties, phaser.getRegisteredParties());
34		assertEquals(unarrived, phaser.getUnarrivedParties());
35		assertEquals(parties - unarrived, phaser.getArrivedParties());
36	<	assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated());
36	>	assertFalse(phaser.isTerminated());
37		}
38
39		/** Checks state of terminated phaser. */
40	<	protected void assertTerminated(Phaser phaser, int parties, int unarrived) {
40	>	protected void assertTerminated(Phaser phaser, int maxPhase, int parties) {
41		assertTrue(phaser.isTerminated());
42	<	assertTrue(phaser.getPhase() < 0);
42	>	int expectedPhase = maxPhase + Integer.MIN_VALUE;
43	>	assertEquals(expectedPhase, phaser.getPhase());
44		assertEquals(parties, phaser.getRegisteredParties());
45	<	assertEquals(unarrived, phaser.getUnarrivedParties());
46	<	assertEquals(parties - unarrived, phaser.getArrivedParties());
45	>	assertEquals(expectedPhase, phaser.register());
46	>	assertEquals(expectedPhase, phaser.arrive());
47	>	assertEquals(expectedPhase, phaser.arriveAndDeregister());
48		}
49
50	<	protected void assertTerminated(Phaser phaser) {
51	<	assertTerminated(phaser, 0, 0);
50	>	protected void assertTerminated(Phaser phaser, int maxPhase) {
51	>	assertTerminated(phaser, maxPhase, 0);
52		}
53
54		/**
#	Line 156 | Line 157 | public class PhaserTest extends JSR166Te
157		phaser.bulkRegister(Integer.MAX_VALUE);
158		shouldThrow();
159		} catch (IllegalStateException success) {}
160	+
161	+	assertEquals(0, phaser.bulkRegister(0));
162	+	assertState(phaser, 0, maxParties, maxParties);
163		}
164
165		/**
166	<	* register() correctly returns the current barrier phase number when
167	<	* invoked
166	>	* register() correctly returns the current barrier phase number
167	>	* when invoked
168		*/
169		public void testRegister3() {
170		Phaser phaser = new Phaser();
#	Line 171 | Line 175 | public class PhaserTest extends JSR166Te
175		}
176
177		/**
178	<	* register causes the next arrive to not increment the phase rather retain
179	<	* the phase number
178	>	* register causes the next arrive to not increment the phase
179	>	* rather retain the phase number
180		*/
181		public void testRegister4() {
182		Phaser phaser = new Phaser(1);
#	Line 183 | Line 187 | public class PhaserTest extends JSR166Te
187		}
188
189		/**
190	+	* register on a subphaser that is currently empty succeeds, even
191	+	* in the presence of another non-empty subphaser
192	+	*/
193	+	public void testRegisterEmptySubPhaser() {
194	+	Phaser root = new Phaser();
195	+	Phaser child1 = new Phaser(root, 1);
196	+	Phaser child2 = new Phaser(root, 0);
197	+	assertEquals(0, child2.register());
198	+	assertState(root, 0, 2, 2);
199	+	assertState(child1, 0, 1, 1);
200	+	assertState(child2, 0, 1, 1);
201	+	assertEquals(0, child2.arriveAndDeregister());
202	+	assertState(root, 0, 1, 1);
203	+	assertState(child1, 0, 1, 1);
204	+	assertState(child2, 0, 0, 0);
205	+	assertEquals(0, child2.register());
206	+	assertEquals(0, child2.arriveAndDeregister());
207	+	assertState(root, 0, 1, 1);
208	+	assertState(child1, 0, 1, 1);
209	+	assertState(child2, 0, 0, 0);
210	+	assertEquals(0, child1.arriveAndDeregister());
211	+	assertTerminated(root, 1);
212	+	assertTerminated(child1, 1);
213	+	assertTerminated(child2, 1);
214	+	}
215	+
216	+	/**
217		* Invoking bulkRegister with a negative parameter throws an
218		* IllegalArgumentException
219		*/
#	Line 194 | Line 225 | public class PhaserTest extends JSR166Te
225		}
226
227		/**
228	<	* bulkRegister should correctly record the number of unarrived parties with
229	<	* the number of parties being registered
228	>	* bulkRegister should correctly record the number of unarrived
229	>	* parties with the number of parties being registered
230		*/
231		public void testBulkRegister2() {
232		Phaser phaser = new Phaser();
233	+	assertEquals(0, phaser.bulkRegister(0));
234	+	assertState(phaser, 0, 0, 0);
235		assertEquals(0, phaser.bulkRegister(20));
236		assertState(phaser, 0, 20, 20);
237		}
#	Line 247 | Line 280 | public class PhaserTest extends JSR166Te
280		/**
281		* arriveAndDeregister does not wait for others to arrive at barrier
282		*/
283	<	public void testArriveAndDeregister() throws InterruptedException {
283	>	public void testArriveAndDeregister() {
284		final Phaser phaser = new Phaser(1);
285		for (int i = 0; i < 10; i++) {
286		assertState(phaser, 0, 1, 1);
#	Line 257 | Line 290 | public class PhaserTest extends JSR166Te
290		assertState(phaser, 0, 1, 1);
291		}
292		assertEquals(0, phaser.arriveAndDeregister());
293	<	assertTerminated(phaser);
261	<	assertEquals(1, phaser.getPhase() + Integer.MIN_VALUE);
293	>	assertTerminated(phaser, 1);
294		}
295
296		/**
297		* arriveAndDeregister does not wait for others to arrive at barrier
298		*/
299	<	public void testArrive2() throws InterruptedException {
299	>	public void testArrive2() {
300		final Phaser phaser = new Phaser();
301		assertEquals(0, phaser.register());
302		List<Thread> threads = new ArrayList<Thread>();
303		for (int i = 0; i < 10; i++) {
304		assertEquals(0, phaser.register());
305		threads.add(newStartedThread(new CheckedRunnable() {
306	<	public void realRun() throws InterruptedException {
306	>	public void realRun() {
307		assertEquals(0, phaser.arriveAndDeregister());
308		}}));
309		}
310
311		for (Thread thread : threads)
312	<	awaitTermination(thread, LONG_DELAY_MS);
312	>	awaitTermination(thread);
313		assertState(phaser, 0, 1, 1);
314		assertEquals(0, phaser.arrive());
315		assertState(phaser, 1, 1, 1);
#	Line 289 | Line 321 | public class PhaserTest extends JSR166Te
321		public void testArrive3() {
322		Phaser phaser = new Phaser(1);
323		phaser.forceTermination();
324	<	assertTerminated(phaser, 1, 1);
324	>	assertTerminated(phaser, 0, 1);
325		assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
326		assertTrue(phaser.arrive() < 0);
327		assertTrue(phaser.register() < 0);
#	Line 336 | Line 368 | public class PhaserTest extends JSR166Te
368		assertState(child, 0, 1, 1);
369		assertState(parent, 0, 1, 1);
370		assertEquals(0, child.arriveAndDeregister());
371	<	assertTerminated(child);
372	<	assertTerminated(parent);
371	>	assertTerminated(child, 1);
372	>	assertTerminated(parent, 1);
373		}
374
375		/**
#	Line 372 | Line 404 | public class PhaserTest extends JSR166Te
404		assertState(parent, 0, 1, 1);
405		assertState(child, 0, 1, 1);
406		assertEquals(0, child.arriveAndDeregister());
407	<	assertTerminated(child);
408	<	assertTerminated(parent);
409	<	assertTerminated(root);
378	<	assertEquals(1, root.getPhase() + Integer.MIN_VALUE);
407	>	assertTerminated(child, 1);
408	>	assertTerminated(parent, 1);
409	>	assertTerminated(root, 1);
410		}
411
412		/**
413		* arriveAndDeregister returns the phase in which it leaves the
414		* phaser in after deregistration
415		*/
416	<	public void testArriveAndDeregister6() throws InterruptedException {
416	>	public void testArriveAndDeregister6() {
417		final Phaser phaser = new Phaser(2);
418		Thread t = newStartedThread(new CheckedRunnable() {
419		public void realRun() {
#	Line 393 | Line 424 | public class PhaserTest extends JSR166Te
424		assertEquals(1, phaser.arriveAndDeregister());
425		assertState(phaser, 1, 1, 1);
426		assertEquals(1, phaser.arriveAndDeregister());
427	<	assertTerminated(phaser);
428	<	assertEquals(2, phaser.getPhase() + Integer.MIN_VALUE);
398	<	awaitTermination(t, SHORT_DELAY_MS);
427	>	assertTerminated(phaser, 2);
428	>	awaitTermination(t);
429		}
430
431		/**
#	Line 418 | Line 448 | public class PhaserTest extends JSR166Te
448		}
449
450		/**
451	+	* awaitAdvanceInterruptibly blocks interruptibly
452	+	*/
453	+	public void testAwaitAdvanceInterruptibly_interruptible() throws InterruptedException {
454	+	final Phaser phaser = new Phaser(1);
455	+	final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
456	+
457	+	Thread t1 = newStartedThread(new CheckedRunnable() {
458	+	public void realRun() {
459	+	Thread.currentThread().interrupt();
460	+	try {
461	+	phaser.awaitAdvanceInterruptibly(0);
462	+	shouldThrow();
463	+	} catch (InterruptedException success) {}
464	+	assertFalse(Thread.interrupted());
465	+
466	+	pleaseInterrupt.countDown();
467	+	try {
468	+	phaser.awaitAdvanceInterruptibly(0);
469	+	shouldThrow();
470	+	} catch (InterruptedException success) {}
471	+	assertFalse(Thread.interrupted());
472	+	}});
473	+
474	+	Thread t2 = newStartedThread(new CheckedRunnable() {
475	+	public void realRun() throws TimeoutException {
476	+	Thread.currentThread().interrupt();
477	+	try {
478	+	phaser.awaitAdvanceInterruptibly(0, 2*LONG_DELAY_MS, MILLISECONDS);
479	+	shouldThrow();
480	+	} catch (InterruptedException success) {}
481	+	assertFalse(Thread.interrupted());
482	+
483	+	pleaseInterrupt.countDown();
484	+	try {
485	+	phaser.awaitAdvanceInterruptibly(0, 2*LONG_DELAY_MS, MILLISECONDS);
486	+	shouldThrow();
487	+	} catch (InterruptedException success) {}
488	+	assertFalse(Thread.interrupted());
489	+	}});
490	+
491	+	await(pleaseInterrupt);
492	+	assertState(phaser, 0, 1, 1);
493	+	assertThreadsStayAlive(t1, t2);
494	+	t1.interrupt();
495	+	t2.interrupt();
496	+	awaitTermination(t1);
497	+	awaitTermination(t2);
498	+	assertState(phaser, 0, 1, 1);
499	+	assertEquals(0, phaser.arrive());
500	+	assertState(phaser, 1, 1, 1);
501	+	}
502	+
503	+	/**
504		* awaitAdvance continues waiting if interrupted before waiting
505		*/
506	<	public void testAwaitAdvanceAfterInterrupt() throws InterruptedException {
506	>	public void testAwaitAdvanceAfterInterrupt() {
507		final Phaser phaser = new Phaser();
508		assertEquals(0, phaser.register());
509	<	final CountDownLatch threadStarted = new CountDownLatch(1);
509	>	final CountDownLatch pleaseArrive = new CountDownLatch(1);
510
511		Thread t = newStartedThread(new CheckedRunnable() {
512	<	public void realRun() throws InterruptedException {
512	>	public void realRun() {
513		Thread.currentThread().interrupt();
514		assertEquals(0, phaser.register());
515		assertEquals(0, phaser.arrive());
516	<	threadStarted.countDown();
516	>	pleaseArrive.countDown();
517		assertTrue(Thread.currentThread().isInterrupted());
518		assertEquals(1, phaser.awaitAdvance(0));
519	<	assertTrue(Thread.currentThread().isInterrupted());
519	>	assertTrue(Thread.interrupted());
520		}});
521
522	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
523	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
522	>	await(pleaseArrive);
523	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
524		assertEquals(0, phaser.arrive());
525	<	awaitTermination(t, SMALL_DELAY_MS);
525	>	awaitTermination(t);
526
527		Thread.currentThread().interrupt();
528		assertEquals(1, phaser.awaitAdvance(0));
#	Line 447 | Line 530 | public class PhaserTest extends JSR166Te
530		}
531
532		/**
533	<	* awaitAdvance continues waiting if interrupted while waiting
533	>	*  awaitAdvance continues waiting if interrupted while waiting
534		*/
535	<	public void testAwaitAdvanceBeforeInterrupt() throws InterruptedException {
535	>	public void testAwaitAdvanceBeforeInterrupt() {
536		final Phaser phaser = new Phaser();
537		assertEquals(0, phaser.register());
538	<	final CountDownLatch threadStarted = new CountDownLatch(1);
538	>	final CountDownLatch pleaseArrive = new CountDownLatch(1);
539
540		Thread t = newStartedThread(new CheckedRunnable() {
541	<	public void realRun() throws InterruptedException {
541	>	public void realRun() {
542		assertEquals(0, phaser.register());
543		assertEquals(0, phaser.arrive());
461	–	threadStarted.countDown();
544		assertFalse(Thread.currentThread().isInterrupted());
545	+	pleaseArrive.countDown();
546		assertEquals(1, phaser.awaitAdvance(0));
547	<	assertTrue(Thread.currentThread().isInterrupted());
547	>	assertTrue(Thread.interrupted());
548		}});
549
550	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
551	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
550	>	await(pleaseArrive);
551	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
552		t.interrupt();
553		assertEquals(0, phaser.arrive());
554	<	awaitTermination(t, SMALL_DELAY_MS);
554	>	awaitTermination(t);
555
556		Thread.currentThread().interrupt();
557		assertEquals(1, phaser.awaitAdvance(0));
#	Line 478 | Line 561 | public class PhaserTest extends JSR166Te
561		/**
562		* arriveAndAwaitAdvance continues waiting if interrupted before waiting
563		*/
564	<	public void testArriveAndAwaitAdvanceAfterInterrupt()
482	<	throws InterruptedException {
564	>	public void testArriveAndAwaitAdvanceAfterInterrupt() {
565		final Phaser phaser = new Phaser();
566		assertEquals(0, phaser.register());
567	<	final CountDownLatch threadStarted = new CountDownLatch(1);
567	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
568
569		Thread t = newStartedThread(new CheckedRunnable() {
570	<	public void realRun() throws InterruptedException {
570	>	public void realRun() {
571		Thread.currentThread().interrupt();
572		assertEquals(0, phaser.register());
573	<	threadStarted.countDown();
573	>	pleaseInterrupt.countDown();
574		assertTrue(Thread.currentThread().isInterrupted());
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		Thread.currentThread().interrupt();
582		assertEquals(1, phaser.arriveAndAwaitAdvance());
583		assertTrue(Thread.interrupted());
584	<	awaitTermination(t, SMALL_DELAY_MS);
584	>	awaitTermination(t);
585		}
586
587		/**
588		* arriveAndAwaitAdvance continues waiting if interrupted while waiting
589		*/
590	<	public void testArriveAndAwaitAdvanceBeforeInterrupt()
509	<	throws InterruptedException {
590	>	public void testArriveAndAwaitAdvanceBeforeInterrupt() {
591		final Phaser phaser = new Phaser();
592		assertEquals(0, phaser.register());
593	<	final CountDownLatch threadStarted = new CountDownLatch(1);
593	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
594
595		Thread t = newStartedThread(new CheckedRunnable() {
596	<	public void realRun() throws InterruptedException {
596	>	public void realRun() {
597		assertEquals(0, phaser.register());
517	–	threadStarted.countDown();
598		assertFalse(Thread.currentThread().isInterrupted());
599	+	pleaseInterrupt.countDown();
600		assertEquals(1, phaser.arriveAndAwaitAdvance());
601		assertTrue(Thread.currentThread().isInterrupted());
602		}});
603
604	<	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
605	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
604	>	await(pleaseInterrupt);
605	>	waitForThreadToEnterWaitState(t, SHORT_DELAY_MS);
606		t.interrupt();
607		Thread.currentThread().interrupt();
608		assertEquals(1, phaser.arriveAndAwaitAdvance());
609		assertTrue(Thread.interrupted());
610	<	awaitTermination(t, SMALL_DELAY_MS);
610	>	awaitTermination(t);
611		}
612
613		/**
614		* awaitAdvance atomically waits for all parties within the same phase to
615		* complete before continuing
616		*/
617	<	public void testAwaitAdvance4() throws InterruptedException {
617	>	public void testAwaitAdvance4() {
618		final Phaser phaser = new Phaser(4);
619		final AtomicInteger count = new AtomicInteger(0);
620		List<Thread> threads = new ArrayList<Thread>();
#	Line 545 | Line 626 | public class PhaserTest extends JSR166Te
626		count.incrementAndGet();
627		assertEquals(2*k+1, phaser.arrive());
628		assertEquals(2*k+2, phaser.awaitAdvance(2*k+1));
629	<	assertEquals(count.get(), 4*(k+1));
629	>	assertEquals(4*(k+1), count.get());
630		}}}));
631
632		for (Thread thread : threads)
633	<	awaitTermination(thread, MEDIUM_DELAY_MS);
633	>	awaitTermination(thread);
634		}
635
636		/**
637		* awaitAdvance returns the current phase
638		*/
639	<	public void testAwaitAdvance5() throws InterruptedException {
639	>	public void testAwaitAdvance5() {
640		final Phaser phaser = new Phaser(1);
641		assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
642		assertEquals(1, phaser.getPhase());
#	Line 565 | Line 646 | public class PhaserTest extends JSR166Te
646		final CountDownLatch latch = new CountDownLatch(1);
647		final boolean goesFirst = ((i & 1) == 0);
648		threads.add(newStartedThread(new CheckedRunnable() {
649	<	public void realRun() throws InterruptedException {
649	>	public void realRun() {
650		if (goesFirst)
651		latch.countDown();
652		else
653	<	assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
653	>	await(latch);
654		phaser.arrive();
655		}}));
656		if (goesFirst)
657	<	assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
657	>	await(latch);
658		else
659		latch.countDown();
660		assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive()));
661		assertEquals(i + 2, phaser.getPhase());
662		}
663		for (Thread thread : threads)
664	<	awaitTermination(thread, SMALL_DELAY_MS);
664	>	awaitTermination(thread);
665	>	}
666	>
667	>	/**
668	>	* awaitAdvance returns the current phase in child phasers
669	>	*/
670	>	public void testAwaitAdvanceTieredPhaser() throws Exception {
671	>	final Phaser parent = new Phaser();
672	>	final List<Phaser> zeroPartyChildren = new ArrayList<Phaser>(3);
673	>	final List<Phaser> onePartyChildren = new ArrayList<Phaser>(3);
674	>	for (int i = 0; i < 3; i++) {
675	>	zeroPartyChildren.add(new Phaser(parent, 0));
676	>	onePartyChildren.add(new Phaser(parent, 1));
677	>	}
678	>	final List<Phaser> phasers = new ArrayList<Phaser>();
679	>	phasers.addAll(zeroPartyChildren);
680	>	phasers.addAll(onePartyChildren);
681	>	phasers.add(parent);
682	>	for (Phaser phaser : phasers) {
683	>	assertEquals(-42, phaser.awaitAdvance(-42));
684	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
685	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
686	>	}
687	>
688	>	for (Phaser child : onePartyChildren)
689	>	assertEquals(0, child.arrive());
690	>	for (Phaser phaser : phasers) {
691	>	assertEquals(-42, phaser.awaitAdvance(-42));
692	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
693	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
694	>	assertEquals(1, phaser.awaitAdvance(0));
695	>	assertEquals(1, phaser.awaitAdvanceInterruptibly(0));
696	>	assertEquals(1, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
697	>	}
698	>
699	>	for (Phaser child : onePartyChildren)
700	>	assertEquals(1, child.arrive());
701	>	for (Phaser phaser : phasers) {
702	>	assertEquals(-42, phaser.awaitAdvance(-42));
703	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42));
704	>	assertEquals(-42, phaser.awaitAdvanceInterruptibly(-42, SMALL_DELAY_MS, MILLISECONDS));
705	>	assertEquals(2, phaser.awaitAdvance(0));
706	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(0));
707	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(0, SMALL_DELAY_MS, MILLISECONDS));
708	>	assertEquals(2, phaser.awaitAdvance(1));
709	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(1));
710	>	assertEquals(2, phaser.awaitAdvanceInterruptibly(1, SMALL_DELAY_MS, MILLISECONDS));
711	>	}
712		}
713
714		/**
715		* awaitAdvance returns when the phaser is externally terminated
716		*/
717	<	public void testAwaitAdvance6() throws InterruptedException {
717	>	public void testAwaitAdvance6() {
718		final Phaser phaser = new Phaser(3);
719	<	final CountDownLatch threadsStarted = new CountDownLatch(2);
719	>	final CountDownLatch pleaseForceTermination = new CountDownLatch(2);
720		final List<Thread> threads = new ArrayList<Thread>();
721		for (int i = 0; i < 2; i++) {
722		Runnable r = new CheckedRunnable() {
723		public void realRun() {
724		assertEquals(0, phaser.arrive());
725	<	threadsStarted.countDown();
725	>	pleaseForceTermination.countDown();
726		assertTrue(phaser.awaitAdvance(0) < 0);
727		assertTrue(phaser.isTerminated());
728		assertTrue(phaser.getPhase() < 0);
#	Line 603 | Line 731 | public class PhaserTest extends JSR166Te
731		}};
732		threads.add(newStartedThread(r));
733		}
734	<	threadsStarted.await();
734	>	await(pleaseForceTermination);
735		phaser.forceTermination();
736	+	assertTrue(phaser.isTerminated());
737		assertEquals(0, phaser.getPhase() + Integer.MIN_VALUE);
738		for (Thread thread : threads)
739	<	awaitTermination(thread, SMALL_DELAY_MS);
611	<	assertTrue(phaser.isTerminated());
612	<	assertTrue(phaser.getPhase() < 0);
739	>	awaitTermination(thread);
740		assertEquals(3, phaser.getRegisteredParties());
741		}
742
#	Line 630 | Line 757 | public class PhaserTest extends JSR166Te
757		* number of arrived parties is the same number that is accounted
758		* for when the main thread awaitsAdvance
759		*/
760	<	public void testArriveAndAwaitAdvance3() throws InterruptedException {
760	>	public void testArriveAndAwaitAdvance3() {
761		final Phaser phaser = new Phaser(1);
762		final int THREADS = 3;
763	<	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
763	>	final CountDownLatch pleaseArrive = new CountDownLatch(THREADS);
764		final List<Thread> threads = new ArrayList<Thread>();
765		for (int i = 0; i < THREADS; i++)
766		threads.add(newStartedThread(new CheckedRunnable() {
767	<	public void realRun() throws InterruptedException {
767	>	public void realRun() {
768		assertEquals(0, phaser.register());
769	<	threadsStarted.countDown();
769	>	pleaseArrive.countDown();
770		assertEquals(1, phaser.arriveAndAwaitAdvance());
771		}}));
772
773	<	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
774	<	long t0 = System.nanoTime();
773	>	await(pleaseArrive);
774	>	long startTime = System.nanoTime();
775		while (phaser.getArrivedParties() < THREADS)
776		Thread.yield();
777		assertEquals(THREADS, phaser.getArrivedParties());
778	<	assertTrue(NANOSECONDS.toMillis(System.nanoTime() - t0) < SMALL_DELAY_MS);
778	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
779	>	for (Thread thread : threads)
780	>	waitForThreadToEnterWaitState(thread, SHORT_DELAY_MS);
781		for (Thread thread : threads)
782		assertTrue(thread.isAlive());
783		assertState(phaser, 0, THREADS + 1, 1);
784		phaser.arriveAndAwaitAdvance();
785		for (Thread thread : threads)
786	<	awaitTermination(thread, SMALL_DELAY_MS);
786	>	awaitTermination(thread);
787		assertState(phaser, 1, THREADS + 1, THREADS + 1);
788		}
789

Diff Legend

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