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.8 by jsr166, Sat Nov 21 20:58:45 2009 UTC vs.
Revision 1.20 by jsr166, Thu Oct 21 23:28:13 2010 UTC

#	Line 8 | Line 8
8		import java.util.ArrayList;
9		import java.util.List;
10		import java.util.concurrent.atomic.AtomicInteger;
11	+	import java.util.concurrent.atomic.AtomicBoolean;
12		import java.util.concurrent.*;
13	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14	+	import static java.util.concurrent.TimeUnit.NANOSECONDS;
15		import junit.framework.Test;
16		import junit.framework.TestSuite;
17
#	Line 22 | Line 25 | public class PhaserTest extends JSR166Te
25		return new TestSuite(PhaserTest.class);
26		}
27
28	+	/** Checks state of phaser. */
29	+	protected void assertState(Phaser phaser,
30	+	int phase, int parties, int unarrived) {
31	+	assertEquals(phase, phaser.getPhase());
32	+	assertEquals(parties, phaser.getRegisteredParties());
33	+	assertEquals(unarrived, phaser.getUnarrivedParties());
34	+	assertEquals(parties - unarrived, phaser.getArrivedParties());
35	+	assertTrue((phaser.getPhase() >= 0) ^ phaser.isTerminated());
36	+	}
37	+
38	+	/** Checks state of terminated phaser. */
39	+	protected void assertTerminated(Phaser phaser, int parties, int unarrived) {
40	+	assertTrue(phaser.isTerminated());
41	+	assertTrue(phaser.getPhase() < 0);
42	+	assertEquals(parties, phaser.getRegisteredParties());
43	+	assertEquals(unarrived, phaser.getUnarrivedParties());
44	+	assertEquals(parties - unarrived, phaser.getArrivedParties());
45	+	}
46	+
47	+	protected void assertTerminated(Phaser phaser) {
48	+	assertTerminated(phaser, 0, 0);
49	+	}
50	+
51		/**
52		* Empty constructor builds a new Phaser with no parent, no registered
53		* parties and initial phase number of 0
#	Line 79 | Line 105 | public class PhaserTest extends JSR166Te
105		*/
106		public void testRegister1() {
107		Phaser phaser = new Phaser();
108	<	assertEquals(0, phaser.getUnarrivedParties());
109	<	phaser.register();
110	<	assertEquals(1, phaser.getUnarrivedParties());
85	<	assertEquals(0, phaser.getArrivedParties());
108	>	assertState(phaser, 0, 0, 0);
109	>	assertEquals(0, phaser.register());
110	>	assertState(phaser, 0, 1, 1);
111		}
112
113		/**
#	Line 90 | Line 115 | public class PhaserTest extends JSR166Te
115		*/
116		public void testRegister2() {
117		Phaser phaser = new Phaser(0);
118	<	int expectedUnnarivedParties = (1 << 16) - 1;
119	<	for (int i = 0; i < expectedUnnarivedParties; i++) {
120	<	phaser.register();
121	<	assertEquals(i + 1, phaser.getUnarrivedParties());
118	>	int maxParties = (1 << 16) - 1;
119	>	assertState(phaser, 0, 0, 0);
120	>	assertEquals(0, phaser.bulkRegister(maxParties - 10));
121	>	assertState(phaser, 0, maxParties - 10, maxParties - 10);
122	>	for (int i = 0; i < 10; i++) {
123	>	assertState(phaser, 0, maxParties - 10 + i, maxParties - 10 + i);
124	>	assertEquals(0, phaser.register());
125		}
126	+	assertState(phaser, 0, maxParties, maxParties);
127		try {
128		phaser.register();
129		shouldThrow();
#	Line 108 | Line 137 | public class PhaserTest extends JSR166Te
137		public void testRegister3() {
138		Phaser phaser = new Phaser();
139		assertEquals(0, phaser.register());
140	<	phaser.arrive();
140	>	assertEquals(0, phaser.arrive());
141		assertEquals(1, phaser.register());
142	+	assertState(phaser, 1, 2, 2);
143		}
144
145		/**
#	Line 118 | Line 148 | public class PhaserTest extends JSR166Te
148		*/
149		public void testRegister4() {
150		Phaser phaser = new Phaser(1);
151	<	phaser.arrive();
152	<	int expectedPhase = phaser.register();
153	<	phaser.arrive();
154	<	assertEquals(expectedPhase, phaser.getPhase());
125	<	}
126	<
127	<	public void testRegister5() {
128	<	Phaser phaser = new Phaser();
129	<	phaser.register();
130	<	assertEquals(1, phaser.getUnarrivedParties());
151	>	assertEquals(0, phaser.arrive());
152	>	assertEquals(1, phaser.register());
153	>	assertEquals(1, phaser.arrive());
154	>	assertState(phaser, 1, 2, 1);
155		}
156
157		/**
#	Line 147 | Line 171 | public class PhaserTest extends JSR166Te
171		*/
172		public void testBulkRegister2() {
173		Phaser phaser = new Phaser();
174	<	phaser.bulkRegister(20);
175	<	assertEquals(20, phaser.getUnarrivedParties());
174	>	assertEquals(0, phaser.bulkRegister(20));
175	>	assertState(phaser, 0, 20, 20);
176		}
177
178		/**
#	Line 156 | Line 180 | public class PhaserTest extends JSR166Te
180		* throws IllegalStateException.
181		*/
182		public void testBulkRegister3() {
183	+	assertEquals(0, new Phaser().bulkRegister((1 << 16) - 1));
184	+
185		try {
186		new Phaser().bulkRegister(1 << 16);
187		shouldThrow();
188		} catch (IllegalStateException success) {}
189	+
190	+	try {
191	+	new Phaser(2).bulkRegister((1 << 16) - 2);
192	+	shouldThrow();
193	+	} catch (IllegalStateException success) {}
194		}
195
196		/**
#	Line 176 | Line 207 | public class PhaserTest extends JSR166Te
207		}
208
209		/**
210	<	*  Arrive() on a registered phaser increments phase.
210	>	* arrive() on a registered phaser increments phase.
211		*/
212		public void testArrive1() {
213		Phaser phaser = new Phaser(1);
214	<	phaser.arrive();
215	<	assertEquals(1, phaser.getPhase());
214	>	assertState(phaser, 0, 1, 1);
215	>	assertEquals(0, phaser.arrive());
216	>	assertState(phaser, 1, 1, 1);
217		}
218
219		/**
220		* arriveAndDeregister does not wait for others to arrive at barrier
221		*/
222	<	public void testArrive2() throws InterruptedException {
222	>	public void testArriveAndDeregister() throws InterruptedException {
223		final Phaser phaser = new Phaser(1);
224	<	phaser.register();
224	>	for (int i = 0; i < 10; i++) {
225	>	assertState(phaser, 0, 1, 1);
226	>	assertEquals(0, phaser.register());
227	>	assertState(phaser, 0, 2, 2);
228	>	assertEquals(0, phaser.arriveAndDeregister());
229	>	assertState(phaser, 0, 1, 1);
230	>	}
231	>	assertEquals(0, phaser.arriveAndDeregister());
232	>	assertTerminated(phaser);
233	>	}
234	>
235	>	/**
236	>	* arriveAndDeregister does not wait for others to arrive at barrier
237	>	*/
238	>	public void testArrive2() throws InterruptedException {
239	>	final Phaser phaser = new Phaser();
240	>	assertEquals(0, phaser.register());
241		List<Thread> threads = new ArrayList<Thread>();
242	<	for (int i = 0; i < 10; i++)
243	<	phaser.register();
242	>	for (int i = 0; i < 10; i++) {
243	>	assertEquals(0, phaser.register());
244		threads.add(newStartedThread(new CheckedRunnable() {
245	<	void realRun() throws InterruptedException {
246	<	Thread.sleep(SMALL_DELAY_MS);
199	<	phaser.arriveAndDeregister();
245	>	public void realRun() throws InterruptedException {
246	>	assertEquals(0, phaser.arriveAndDeregister());
247		}}));
248	+	}
249
202	–	phaser.arrive();
203	–	assertTrue(threads.get(0).isAlive());
204	–	assertFalse(phaser.isTerminated());
250		for (Thread thread : threads)
251	<	thread.join();
251	>	awaitTermination(thread, LONG_DELAY_MS);
252	>	assertState(phaser, 0, 1, 1);
253	>	assertEquals(0, phaser.arrive());
254	>	assertState(phaser, 1, 1, 1);
255		}
256
257		/**
#	Line 212 | Line 260 | public class PhaserTest extends JSR166Te
260		public void testArrive3() {
261		Phaser phaser = new Phaser(1);
262		phaser.forceTermination();
263	+	assertTerminated(phaser, 1, 1);
264		assertTrue(phaser.arrive() < 0);
265	+	assertTrue(phaser.register() < 0);
266	+	assertTrue(phaser.arriveAndDeregister() < 0);
267	+	assertTrue(phaser.awaitAdvance(1) < 0);
268	+	assertTrue(phaser.getPhase() < 0);
269		}
270
271		/**
#	Line 228 | Line 281 | public class PhaserTest extends JSR166Te
281		}
282
283		/**
284	<	* arriveAndDeregister deregisters reduces the number of arrived parties
284	>	* arriveAndDeregister reduces the number of arrived parties
285		*/
286	<	public void testArriveAndDergeister2() {
286	>	public void testArriveAndDeregister2() {
287		final Phaser phaser = new Phaser(1);
288	<	phaser.register();
289	<	phaser.arrive();
290	<	int p = phaser.getArrivedParties();
291	<	assertTrue(p == 1);
292	<	phaser.arriveAndDeregister();
240	<	assertTrue(phaser.getArrivedParties() < p);
288	>	assertEquals(0, phaser.register());
289	>	assertEquals(0, phaser.arrive());
290	>	assertState(phaser, 0, 2, 1);
291	>	assertEquals(0, phaser.arriveAndDeregister());
292	>	assertState(phaser, 1, 1, 1);
293		}
294
295		/**
296	<	* arriveAndDeregister arrives to the barrier on a phaser with a parent and
296	>	* arriveAndDeregister arrives at the barrier on a phaser with a parent and
297		* when a deregistration occurs and causes the phaser to have zero parties
298		* its parent will be deregistered as well
299		*/
300	<	public void testArriveAndDeregsiter3() {
300	>	public void testArriveAndDeregister3() {
301		Phaser parent = new Phaser();
302	<	Phaser root = new Phaser(parent);
303	<	root.register();
304	<	assertTrue(parent.getUnarrivedParties() > 0);
305	<	assertTrue(root.getUnarrivedParties() > 0);
306	<	root.arriveAndDeregister();
307	<	assertTrue(parent.getUnarrivedParties() == 0);
308	<	assertTrue(root.getUnarrivedParties() == 0);
309	<	assertTrue(root.isTerminated() && parent.isTerminated());
302	>	Phaser child = new Phaser(parent);
303	>	assertState(child, 0, 0, 0);
304	>	assertState(parent, 0, 1, 1);
305	>	assertEquals(0, child.register());
306	>	assertState(child, 0, 1, 1);
307	>	assertState(parent, 0, 1, 1);
308	>	assertEquals(0, child.arriveAndDeregister());
309	>	assertTerminated(child);
310	>	assertTerminated(parent);
311		}
312
313		/**
314		* arriveAndDeregister deregisters one party from its parent when
315	<	* the number of parties of root is zero after deregistration
315	>	* the number of parties of child is zero after deregistration
316		*/
317	<	public void testArriveAndDeregsiter4() {
317	>	public void testArriveAndDeregister4() {
318		Phaser parent = new Phaser();
319	<	Phaser root = new Phaser(parent);
320	<	parent.register();
321	<	root.register();
322	<	int parentParties = parent.getUnarrivedParties();
323	<	root.arriveAndDeregister();
324	<	assertEquals(parentParties - 1, parent.getUnarrivedParties());
319	>	Phaser child = new Phaser(parent);
320	>	assertEquals(0, parent.register());
321	>	assertEquals(0, child.register());
322	>	assertState(child, 0, 1, 1);
323	>	assertState(parent, 0, 2, 2);
324	>	assertEquals(0, child.arriveAndDeregister());
325	>	assertState(child, 0, 0, 0);
326	>	assertState(parent, 0, 1, 1);
327		}
328
329		/**
#	Line 276 | Line 331 | public class PhaserTest extends JSR166Te
331		* the number of parties of root is nonzero after deregistration.
332		*/
333		public void testArriveAndDeregister5() {
334	<	Phaser parent = new Phaser();
334	>	Phaser root = new Phaser();
335	>	Phaser parent = new Phaser(root);
336		Phaser child = new Phaser(parent);
337	<	Phaser root = new Phaser(child);
338	<	assertTrue(parent.getUnarrivedParties() > 0);
339	<	assertTrue(child.getUnarrivedParties() > 0);
340	<	root.register();
341	<	root.arriveAndDeregister();
342	<	assertTrue(parent.getUnarrivedParties() == 0);
343	<	assertTrue(child.getUnarrivedParties() == 0);
344	<	assertTrue(root.isTerminated());
337	>	assertState(root, 0, 1, 1);
338	>	assertState(parent, 0, 1, 1);
339	>	assertState(child, 0, 0, 0);
340	>	assertEquals(0, child.register());
341	>	assertState(root, 0, 1, 1);
342	>	assertState(parent, 0, 1, 1);
343	>	assertState(child, 0, 1, 1);
344	>	assertEquals(0, child.arriveAndDeregister());
345	>	assertTerminated(child);
346	>	assertTerminated(parent);
347	>	assertTerminated(root);
348		}
349
350		/**
#	Line 295 | Line 354 | public class PhaserTest extends JSR166Te
354		public void testArriveAndDeregister6() throws InterruptedException {
355		final Phaser phaser = new Phaser(2);
356		Thread t = newStartedThread(new CheckedRunnable() {
357	<	void realRun() {
358	<	sleepTillInterrupted(SHORT_DELAY_MS);
300	<	phaser.arrive();
357	>	public void realRun() {
358	>	assertEquals(0, phaser.arrive());
359		}});
360	<	phaser.arriveAndAwaitAdvance();
361	<	int phase = phaser.arriveAndDeregister();
362	<	assertEquals(phase, phaser.getPhase());
363	<	t.join();
360	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
361	>	assertState(phaser, 1, 2, 2);
362	>	assertEquals(1, phaser.arriveAndDeregister());
363	>	assertState(phaser, 1, 1, 1);
364	>	assertEquals(1, phaser.arriveAndDeregister());
365	>	assertTerminated(phaser);
366	>	awaitTermination(t, SHORT_DELAY_MS);
367		}
368
369		/**
#	Line 310 | Line 371 | public class PhaserTest extends JSR166Te
371		*/
372		public void testAwaitAdvance1() {
373		final Phaser phaser = new Phaser(1);
374	<	phaser.awaitAdvance(phaser.arrive());
374	>	assertEquals(0, phaser.arrive());
375	>	assertEquals(1, phaser.awaitAdvance(0));
376		}
377
378		/**
#	Line 319 | Line 381 | public class PhaserTest extends JSR166Te
381		*/
382		public void testAwaitAdvance2() {
383		Phaser phaser = new Phaser();
384	<	phaser.awaitAdvance(-1);
384	>	assertTrue(phaser.awaitAdvance(-1) < 0);
385	>	assertState(phaser, 0, 0, 0);
386		}
387
388		/**
389	<	* awaitAdvance while waiting does not abort on interrupt.
389	>	* awaitAdvance continues waiting if interrupted before waiting
390		*/
391	<	public void testAwaitAdvance3() throws InterruptedException {
391	>	public void testAwaitAdvanceAfterInterrupt() throws InterruptedException {
392		final Phaser phaser = new Phaser();
393	<	phaser.register();
393	>	assertEquals(0, phaser.register());
394	>	final CountDownLatch threadStarted = new CountDownLatch(1);
395	>
396	>	Thread t = newStartedThread(new CheckedRunnable() {
397	>	public void realRun() throws InterruptedException {
398	>	Thread.currentThread().interrupt();
399	>	assertEquals(0, phaser.register());
400	>	assertEquals(0, phaser.arrive());
401	>	threadStarted.countDown();
402	>	assertTrue(Thread.currentThread().isInterrupted());
403	>	assertEquals(1, phaser.awaitAdvance(0));
404	>	assertTrue(Thread.currentThread().isInterrupted());
405	>	}});
406	>
407	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
408	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
409	>	assertEquals(0, phaser.arrive());
410	>	awaitTermination(t, SMALL_DELAY_MS);
411	>
412	>	Thread.currentThread().interrupt();
413	>	assertEquals(1, phaser.awaitAdvance(0));
414	>	assertTrue(Thread.interrupted());
415	>	}
416	>
417	>	/**
418	>	* awaitAdvance continues waiting if interrupted while waiting
419	>	*/
420	>	public void testAwaitAdvanceBeforeInterrupt() throws InterruptedException {
421	>	final Phaser phaser = new Phaser();
422	>	assertEquals(0, phaser.register());
423	>	final CountDownLatch threadStarted = new CountDownLatch(1);
424
425		Thread t = newStartedThread(new CheckedRunnable() {
426	<	void realRun() throws InterruptedException {
427	<	phaser.register();
428	<	sleepTillInterrupted(LONG_DELAY_MS);
429	<	phaser.awaitAdvance(phaser.arrive());
426	>	public void realRun() throws InterruptedException {
427	>	assertEquals(0, phaser.register());
428	>	assertEquals(0, phaser.arrive());
429	>	threadStarted.countDown();
430	>	assertFalse(Thread.currentThread().isInterrupted());
431	>	assertEquals(1, phaser.awaitAdvance(0));
432	>	assertTrue(Thread.currentThread().isInterrupted());
433		}});
434	<	Thread.sleep(SMALL_DELAY_MS);
434	>
435	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
436	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
437	>	t.interrupt();
438	>	assertEquals(0, phaser.arrive());
439	>	awaitTermination(t, SMALL_DELAY_MS);
440	>
441	>	Thread.currentThread().interrupt();
442	>	assertEquals(1, phaser.awaitAdvance(0));
443	>	assertTrue(Thread.interrupted());
444	>	}
445	>
446	>	/**
447	>	* arriveAndAwaitAdvance continues waiting if interrupted before waiting
448	>	*/
449	>	public void testArriveAndAwaitAdvanceAfterInterrupt()
450	>	throws InterruptedException {
451	>	final Phaser phaser = new Phaser();
452	>	assertEquals(0, phaser.register());
453	>	final CountDownLatch threadStarted = new CountDownLatch(1);
454	>
455	>	Thread t = newStartedThread(new CheckedRunnable() {
456	>	public void realRun() throws InterruptedException {
457	>	Thread.currentThread().interrupt();
458	>	assertEquals(0, phaser.register());
459	>	threadStarted.countDown();
460	>	assertTrue(Thread.currentThread().isInterrupted());
461	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
462	>	assertTrue(Thread.currentThread().isInterrupted());
463	>	}});
464	>
465	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
466	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
467	>	Thread.currentThread().interrupt();
468	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
469	>	assertTrue(Thread.interrupted());
470	>	awaitTermination(t, SMALL_DELAY_MS);
471	>	}
472	>
473	>	/**
474	>	* arriveAndAwaitAdvance continues waiting if interrupted while waiting
475	>	*/
476	>	public void testArriveAndAwaitAdvanceBeforeInterrupt()
477	>	throws InterruptedException {
478	>	final Phaser phaser = new Phaser();
479	>	assertEquals(0, phaser.register());
480	>	final CountDownLatch threadStarted = new CountDownLatch(1);
481	>
482	>	Thread t = newStartedThread(new CheckedRunnable() {
483	>	public void realRun() throws InterruptedException {
484	>	assertEquals(0, phaser.register());
485	>	threadStarted.countDown();
486	>	assertFalse(Thread.currentThread().isInterrupted());
487	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
488	>	assertTrue(Thread.currentThread().isInterrupted());
489	>	}});
490	>
491	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
492	>	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
493		t.interrupt();
494	<	Thread.sleep(SMALL_DELAY_MS);
495	<	phaser.arrive();
496	<	assertFalse(t.isInterrupted());
497	<	t.join();
494	>	Thread.currentThread().interrupt();
495	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
496	>	assertTrue(Thread.interrupted());
497	>	awaitTermination(t, SMALL_DELAY_MS);
498		}
499
500		/**
#	Line 349 | Line 503 | public class PhaserTest extends JSR166Te
503		*/
504		public void testAwaitAdvance4() throws InterruptedException {
505		final Phaser phaser = new Phaser(4);
506	<	final AtomicInteger phaseCount = new AtomicInteger(0);
506	>	final AtomicInteger count = new AtomicInteger(0);
507		List<Thread> threads = new ArrayList<Thread>();
508	<	for (int i = 0; i < 4; i++) {
508	>	for (int i = 0; i < 4; i++)
509		threads.add(newStartedThread(new CheckedRunnable() {
510	<	void realRun() {
511	<	int phase = phaser.arrive();
512	<	phaseCount.incrementAndGet();
513	<	sleepTillInterrupted(SMALL_DELAY_MS);
514	<	phaser.awaitAdvance(phase);
515	<	threadAssertTrue(phaseCount.get() == 4);
516	<	}}));
517	<	}
510	>	public void realRun() {
511	>	for (int k = 0; k < 3; k++) {
512	>	assertEquals(2*k+1, phaser.arriveAndAwaitAdvance());
513	>	count.incrementAndGet();
514	>	assertEquals(2*k+1, phaser.arrive());
515	>	assertEquals(2*k+2, phaser.awaitAdvance(2*k+1));
516	>	assertEquals(count.get(), 4*(k+1));
517	>	}}}));
518	>
519		for (Thread thread : threads)
520	<	thread.join();
520	>	awaitTermination(thread, MEDIUM_DELAY_MS);
521		}
522
523		/**
#	Line 370 | Line 525 | public class PhaserTest extends JSR166Te
525		*/
526		public void testAwaitAdvance5() throws InterruptedException {
527		final Phaser phaser = new Phaser(1);
528	<	int phase = phaser.awaitAdvance(phaser.arrive());
529	<	assertEquals(phase, phaser.getPhase());
530	<	phaser.register();
528	>	assertEquals(1, phaser.awaitAdvance(phaser.arrive()));
529	>	assertEquals(1, phaser.getPhase());
530	>	assertEquals(1, phaser.register());
531		List<Thread> threads = new ArrayList<Thread>();
532		for (int i = 0; i < 8; i++) {
533	+	final CountDownLatch latch = new CountDownLatch(1);
534	+	final boolean goesFirst = ((i & 1) == 0);
535		threads.add(newStartedThread(new CheckedRunnable() {
536	<	void realRun() {
537	<	sleepTillInterrupted(SHORT_DELAY_MS);
536	>	public void realRun() throws InterruptedException {
537	>	if (goesFirst)
538	>	latch.countDown();
539	>	else
540	>	assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
541		phaser.arrive();
542		}}));
543	<	phase = phaser.awaitAdvance(phaser.arrive());
544	<	threadAssertEquals(phase, phaser.getPhase());
543	>	if (goesFirst)
544	>	assertTrue(latch.await(SMALL_DELAY_MS, MILLISECONDS));
545	>	else
546	>	latch.countDown();
547	>	assertEquals(i + 2, phaser.awaitAdvance(phaser.arrive()));
548	>	assertEquals(i + 2, phaser.getPhase());
549		}
550		for (Thread thread : threads)
551	<	thread.join();
551	>	awaitTermination(thread, SMALL_DELAY_MS);
552		}
553
554		/**
#	Line 392 | Line 556 | public class PhaserTest extends JSR166Te
556		*/
557		public void testAwaitAdvance6() throws InterruptedException {
558		final Phaser phaser = new Phaser(3);
559	<	/*
560	<	* Start new thread. This thread waits a small amount of time
561	<	* and waits for the other two parties to arrive.  The party
562	<	* in the main thread arrives quickly so at best this thread
563	<	* waits for the second thread's party to arrive
564	<	*/
565	<	Thread t1 = newStartedThread(new CheckedRunnable() {
566	<	void realRun() {
567	<	sleepTillInterrupted(SMALL_DELAY_MS);
568	<	int phase = phaser.awaitAdvance(phaser.arrive());
569	<	/*
570	<	* This point is reached when force termination is called in which phase = -1
571	<	*/
572	<	threadAssertTrue(phase < 0);
573	<	threadAssertTrue(phaser.isTerminated());
410	<	}});
411	<	/*
412	<	* This thread will cause the first thread run to wait, in doing so
413	<	* the main thread will force termination in which the first thread
414	<	* should exit peacefully as this one
415	<	*/
416	<	Thread t2 = newStartedThread(new CheckedRunnable() {
417	<	void realRun() {
418	<	sleepTillInterrupted(MEDIUM_DELAY_MS);
419	<	int p1 = phaser.arrive();
420	<	int phase = phaser.awaitAdvance(p1);
421	<	threadAssertTrue(phase < 0);
422	<	threadAssertTrue(phaser.isTerminated());
423	<	}});
424	<
425	<	phaser.arrive();
559	>	final CountDownLatch threadsStarted = new CountDownLatch(2);
560	>	final List<Thread> threads = new ArrayList<Thread>();
561	>	for (int i = 0; i < 2; i++) {
562	>	Runnable r = new CheckedRunnable() {
563	>	public void realRun() {
564	>	assertEquals(0, phaser.arrive());
565	>	threadsStarted.countDown();
566	>	assertTrue(phaser.awaitAdvance(0) < 0);
567	>	assertTrue(phaser.isTerminated());
568	>	assertTrue(phaser.getPhase() < 0);
569	>	assertEquals(3, phaser.getRegisteredParties());
570	>	}};
571	>	threads.add(newStartedThread(r));
572	>	}
573	>	threadsStarted.await();
574		phaser.forceTermination();
575	<	t1.join();
576	<	t2.join();
575	>	for (Thread thread : threads)
576	>	awaitTermination(thread, SMALL_DELAY_MS);
577	>	assertTrue(phaser.isTerminated());
578	>	assertTrue(phaser.getPhase() < 0);
579	>	assertEquals(3, phaser.getRegisteredParties());
580		}
581
582		/**
#	Line 441 | Line 592 | public class PhaserTest extends JSR166Te
592		}
593
594		/**
444	–	* Interrupted arriveAndAwaitAdvance does not throw InterruptedException
445	–	*/
446	–	public void testArriveAndAwaitAdvance2() throws InterruptedException {
447	–	final Phaser phaser = new Phaser(2);
448	–	Thread th = newStartedThread(new CheckedRunnable() {
449	–	void realRun() {
450	–	phaser.arriveAndAwaitAdvance();
451	–	}});
452	–
453	–	Thread.sleep(SMALL_DELAY_MS);
454	–	th.interrupt();
455	–	Thread.sleep(SMALL_DELAY_MS);
456	–	phaser.arrive();
457	–	assertFalse(th.isInterrupted());
458	–	th.join();
459	–	}
460	–
461	–	/**
595		* arriveAndAwaitAdvance waits for all threads to arrive, the
596		* number of arrived parties is the same number that is accounted
597		* for when the main thread awaitsAdvance
598		*/
599		public void testArriveAndAwaitAdvance3() throws InterruptedException {
600		final Phaser phaser = new Phaser(1);
601	<	final AtomicInteger arrivingCount = new AtomicInteger(0);
601	>	final int THREADS = 3;
602	>	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
603		final List<Thread> threads = new ArrayList<Thread>();
604	<	for (int i = 0; i < 6; i++) {
604	>	for (int i = 0; i < THREADS; i++)
605		threads.add(newStartedThread(new CheckedRunnable() {
606	<	void realRun() throws InterruptedException {
607	<	phaser.register();
608	<	sleepTillInterrupted(SHORT_DELAY_MS);
609	<	arrivingCount.getAndIncrement();
476	<	phaser.arrive();
606	>	public void realRun() throws InterruptedException {
607	>	assertEquals(0, phaser.register());
608	>	threadsStarted.countDown();
609	>	assertEquals(1, phaser.arriveAndAwaitAdvance());
610		}}));
611	<	}
612	<	int phaseNumber = phaser.arriveAndAwaitAdvance();
613	<	arrivingCount.incrementAndGet();
614	<	//the + 1 adds to expectedArrive to account for the main threads arrival
615	<	int expectedArrived = phaseNumber > 0 ? phaseNumber * six + 1 : phaser.getArrivedParties() + 1;
616	<	threadAssertEquals(expectedArrived, arrivingCount.get());
611	>
612	>	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
613	>	long t0 = System.nanoTime();
614	>	while (phaser.getArrivedParties() < THREADS)
615	>	Thread.yield();
616	>	assertEquals(THREADS, phaser.getArrivedParties());
617	>	assertTrue(NANOSECONDS.toMillis(System.nanoTime() - t0) < SMALL_DELAY_MS);
618	>	for (Thread thread : threads)
619	>	assertTrue(thread.isAlive());
620	>	assertState(phaser, 0, THREADS + 1, 1);
621	>	phaser.arriveAndAwaitAdvance();
622		for (Thread thread : threads)
623	<	thread.join();
623	>	awaitTermination(thread, SMALL_DELAY_MS);
624	>	assertState(phaser, 1, THREADS + 1, THREADS + 1);
625		}
626
627		}

Diff Legend

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