ViewVC Help

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

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

Comparing jsr166/src/test/tck/CyclicBarrierTest.java (file contents):
Revision 1.24 by jsr166, Tue May 31 16:16:23 2011 UTC vs.
Revision 1.34 by jsr166, Mon Sep 9 00:46:44 2019 UTC

#	Line 6 | Line 6
6		* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
10	<	import java.util.*;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>
11		import java.util.concurrent.BrokenBarrierException;
12		import java.util.concurrent.CountDownLatch;
13		import java.util.concurrent.CyclicBarrier;
14	+	import java.util.concurrent.ExecutorService;
15	+	import java.util.concurrent.Executors;
16	+	import java.util.concurrent.ThreadLocalRandom;
17		import java.util.concurrent.TimeoutException;
18	<	import java.util.concurrent.atomic.AtomicBoolean;
19	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
18	>	import java.util.concurrent.atomic.AtomicInteger;
19	>
20	>	import junit.framework.Test;
21	>	import junit.framework.TestSuite;
22
23		public class CyclicBarrierTest extends JSR166TestCase {
24		public static void main(String[] args) {
25	<	junit.textui.TestRunner.run(suite());
25	>	main(suite(), args);
26		}
27		public static Test suite() {
28		return new TestSuite(CyclicBarrierTest.class);
29		}
30
26	–	private volatile int countAction;
27	–	private class MyAction implements Runnable {
28	–	public void run() { ++countAction; }
29	–	}
30	–
31		/**
32		* Spin-waits till the number of waiters == numberOfWaiters.
33		*/
#	Line 41 | Line 41 | public class CyclicBarrierTest extends J
41		}
42
43		/**
44	<	* Creating with negative parties throws IAE
44	>	* Creating with negative parties throws IllegalArgumentException
45		*/
46		public void testConstructor1() {
47		try {
#	Line 51 | Line 51 | public class CyclicBarrierTest extends J
51		}
52
53		/**
54	<	* Creating with negative parties and no action throws IAE
54	>	* Creating with negative parties and no action throws
55	>	* IllegalArgumentException
56		*/
57		public void testConstructor2() {
58		try {
#	Line 85 | Line 86 | public class CyclicBarrierTest extends J
86		* The supplied barrier action is run at barrier
87		*/
88		public void testBarrierAction() throws Exception {
89	<	countAction = 0;
90	<	CyclicBarrier b = new CyclicBarrier(1, new MyAction());
89	>	final AtomicInteger count = new AtomicInteger(0);
90	>	final Runnable incCount = new Runnable() { public void run() {
91	>	count.getAndIncrement(); }};
92	>	CyclicBarrier b = new CyclicBarrier(1, incCount);
93		assertEquals(1, b.getParties());
94		assertEquals(0, b.getNumberWaiting());
95		b.await();
96		b.await();
97		assertEquals(0, b.getNumberWaiting());
98	<	assertEquals(countAction, 2);
98	>	assertEquals(2, count.get());
99		}
100
101		/**
#	Line 292 | Line 295 | public class CyclicBarrierTest extends J
295		}
296
297		/**
295	–	* All threads block while a barrier is broken.
296	–	*/
297	–	public void testReset_Leakage() throws InterruptedException {
298	–	final CyclicBarrier c = new CyclicBarrier(2);
299	–	final AtomicBoolean done = new AtomicBoolean();
300	–	Thread t = newStartedThread(new CheckedRunnable() {
301	–	public void realRun() {
302	–	while (!done.get()) {
303	–	try {
304	–	while (c.isBroken())
305	–	c.reset();
306	–
307	–	c.await();
308	–	shouldThrow();
309	–	}
310	–	catch (BrokenBarrierException ok) {}
311	–	catch (InterruptedException ok) {}
312	–	}}});
313	–
314	–	for (int i = 0; i < 4; i++) {
315	–	delay(timeoutMillis());
316	–	t.interrupt();
317	–	}
318	–	done.set(true);
319	–	t.interrupt();
320	–	awaitTermination(t);
321	–	}
322	–
323	–	/**
298		* Reset of a non-broken barrier does not break barrier
299		*/
300		public void testResetWithoutBreakage() throws Exception {
#	Line 459 | Line 433 | public class CyclicBarrierTest extends J
433		assertEquals(0, barrier.getNumberWaiting());
434		}
435		}
436	+
437	+	/**
438	+	* There can be more threads calling await() than parties, as long as each
439	+	* task only calls await once and the task count is a multiple of parties.
440	+	*/
441	+	public void testMoreTasksThanParties() throws Exception {
442	+	final ThreadLocalRandom rnd = ThreadLocalRandom.current();
443	+	final int parties = rnd.nextInt(1, 5);
444	+	final int nTasks = rnd.nextInt(1, 5) * parties;
445	+	final AtomicInteger tripCount = new AtomicInteger(0);
446	+	final AtomicInteger awaitCount = new AtomicInteger(0);
447	+	final CyclicBarrier barrier =
448	+	new CyclicBarrier(parties, () -> tripCount.getAndIncrement());
449	+	final ExecutorService e = Executors.newFixedThreadPool(nTasks);
450	+	final Runnable awaiter = () -> {
451	+	try {
452	+	if (randomBoolean())
453	+	barrier.await();
454	+	else
455	+	barrier.await(LONG_DELAY_MS, MILLISECONDS);
456	+	awaitCount.getAndIncrement();
457	+	} catch (Throwable fail) { threadUnexpectedException(fail); }};
458	+	try (PoolCleaner cleaner = cleaner(e)) {
459	+	for (int i = nTasks; i--> 0; )
460	+	e.execute(awaiter);
461	+	}
462	+	assertEquals(nTasks / parties, tripCount.get());
463	+	assertEquals(nTasks, awaitCount.get());
464	+	assertEquals(0, barrier.getNumberWaiting());
465	+	}
466		}

Diff Legend

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