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.23 by jsr166, Sun May 29 15:31:36 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.*;
11	–	import java.util.concurrent.*;
12	–	import java.util.concurrent.locks.*;
13	–	import java.util.concurrent.atomic.*;
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.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
24	–	private volatile int countAction;
25	–	private class MyAction implements Runnable {
26	–	public void run() { ++countAction; }
27	–	}
28	–
31		/**
32		* Spin-waits till the number of waiters == numberOfWaiters.
33		*/
#	Line 39 | 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 49 | 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 83 | 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 290 | Line 295 | public class CyclicBarrierTest extends J
295		}
296
297		/**
293	–	* All threads block while a barrier is broken.
294	–	*/
295	–	public void testReset_Leakage() throws InterruptedException {
296	–	final CyclicBarrier c = new CyclicBarrier(2);
297	–	final AtomicBoolean done = new AtomicBoolean();
298	–	Thread t = newStartedThread(new CheckedRunnable() {
299	–	public void realRun() {
300	–	while (!done.get()) {
301	–	try {
302	–	while (c.isBroken())
303	–	c.reset();
304	–
305	–	c.await();
306	–	shouldThrow();
307	–	}
308	–	catch (BrokenBarrierException ok) {}
309	–	catch (InterruptedException ok) {}
310	–	}}});
311	–
312	–	for (int i = 0; i < 4; i++) {
313	–	delay(timeoutMillis());
314	–	t.interrupt();
315	–	}
316	–	done.set(true);
317	–	t.interrupt();
318	–	awaitTermination(t);
319	–	}
320	–
321	–	/**
298		* Reset of a non-broken barrier does not break barrier
299		*/
300		public void testResetWithoutBreakage() throws Exception {
#	Line 457 | 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