ViewVC Help

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

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

Comparing jsr166/src/test/tck/ForkJoinPool8Test.java (file contents):
Revision 1.15 by dl, Sun Sep 15 22:35:46 2013 UTC vs.
Revision 1.27 by jsr166, Sat Nov 1 19:18:12 2014 UTC

#	Line 1485 | Line 1485 | public class ForkJoinPool8Test extends J
1485		}
1486
1487		/**
1488	<	* awaitQuiescent by a worker is equivalent in effect to
1488	>	* awaitQuiescence by a worker is equivalent in effect to
1489		* ForkJoinTask.helpQuiesce()
1490		*/
1491	<	public void testAwaitQuiescent1() throws Exception {
1491	>	public void testAwaitQuiescence1() throws Exception {
1492		final ForkJoinPool p = new ForkJoinPool();
1493		try {
1494		final long startTime = System.nanoTime();
1495		assertTrue(p.isQuiescent());
1496		ForkJoinTask a = new CheckedRecursiveAction() {
1497	<	protected void realCompute() {
1498	<	FibAction f = new FibAction(8);
1499	<	assertSame(f, f.fork());
1500	<	boolean t = ForkJoinTask.getPool().awaitQuiescence(MEDIUM_DELAY_MS, TimeUnit.SECONDS);
1501	<	assertTrue(t);
1502	<	while (!f.isDone()) {
1503	<	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1504	<	threadFail("timed out");
1505	<	assertFalse(p.getAsyncMode());
1506	<	assertFalse(p.isShutdown());
1507	<	assertFalse(p.isTerminating());
1508	<	assertFalse(p.isTerminated());
1509	<	Thread.yield();
1510	<	}
1511	<	assertFalse(p.isQuiescent());
1512	<	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1513	<	try {
1514	<	assertEquals(21, f.result);
1515	<	} catch (Throwable fail) {
1516	<	threadFail(fail.getMessage());
1517	<	}
1497	>	protected void realCompute() {
1498	>	FibAction f = new FibAction(8);
1499	>	assertSame(f, f.fork());
1500	>	assertSame(p, ForkJoinTask.getPool());
1501	>	boolean quiescent = p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS);
1502	>	assertTrue(quiescent);
1503	>	assertFalse(p.isQuiescent());
1504	>	while (!f.isDone()) {
1505	>	assertFalse(p.getAsyncMode());
1506	>	assertFalse(p.isShutdown());
1507	>	assertFalse(p.isTerminating());
1508	>	assertFalse(p.isTerminated());
1509	>	Thread.yield();
1510		}
1511	<	};
1511	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1512	>	assertFalse(p.isQuiescent());
1513	>	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1514	>	assertEquals(21, f.result);
1515	>	}};
1516		p.execute(a);
1517		while (!a.isDone() || !p.isQuiescent()) {
1522	–	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1523	–	throw new AssertionFailedError("timed out");
1518		assertFalse(p.getAsyncMode());
1519		assertFalse(p.isShutdown());
1520		assertFalse(p.isTerminating());
1521		assertFalse(p.isTerminated());
1522		Thread.yield();
1523		}
1524	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1525		assertEquals(0, p.getQueuedTaskCount());
1526		assertFalse(p.getAsyncMode());
1527		assertEquals(0, p.getActiveThreadCount());
#	Line 1542 | Line 1537 | public class ForkJoinPool8Test extends J
1537		}
1538
1539		/**
1540	<	* awaitQuiescent returns when pool isQuiescent() or the indicated
1541	<	* timeout elapse
1540	>	* awaitQuiescence returns when pool isQuiescent() or the indicated
1541	>	* timeout elapsed
1542		*/
1543	<	public void testAwaitQuiescent2() throws Exception {
1543	>	public void testAwaitQuiescence2() throws Exception {
1544	>	/**
1545	>	* """It is possible to disable or limit the use of threads in the
1546	>	* common pool by setting the parallelism property to zero. However
1547	>	* doing so may cause unjoined tasks to never be executed."""
1548	>	*/
1549	>	if ("0".equals(System.getProperty(
1550	>	"java.util.concurrent.ForkJoinPool.common.parallelism")))
1551	>	return;
1552		final ForkJoinPool p = new ForkJoinPool();
1553		try {
1554		assertTrue(p.isQuiescent());
1555	<	for (;;) {
1556	<	final long startTime = System.nanoTime();
1557	<	ForkJoinTask a = new CheckedRecursiveAction() {
1558	<	protected void realCompute() {
1559	<	FibAction f = new FibAction(8);
1560	<	assertSame(f, f.fork());
1561	<	ForkJoinTask.helpQuiesce();
1562	<	while (!f.isDone()) {
1563	<	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1564	<	threadFail("timed out");
1565	<	assertFalse(p.getAsyncMode());
1566	<	assertFalse(p.isShutdown());
1567	<	assertFalse(p.isTerminating());
1568	<	assertFalse(p.isTerminated());
1569	<	Thread.yield();
1570	<	}
1571	<	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1572	<	try {
1573	<	assertEquals(21, f.result);
1574	<	} catch (Throwable fail) { System.out.println("fail " + fail.getMessage()); }
1575	<	}
1576	<	};
1577	<	p.execute(a);
1578	<	if (a.isDone() || p.isQuiescent())
1579	<	continue; // Already done so cannot test; retry
1580	<	while (!p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS)) {
1581	<	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
1582	<	threadFail("timed out");
1583	<	assertFalse(p.getAsyncMode());
1584	<	assertFalse(p.isShutdown());
1585	<	assertFalse(p.isTerminating());
1583	<	assertFalse(p.isTerminated());
1584	<	Thread.yield();
1585	<	}
1586	<	assertTrue(p.isQuiescent());
1587	<	assertTrue(a.isDone());
1588	<	assertEquals(0, p.getQueuedTaskCount());
1589	<	assertFalse(p.getAsyncMode());
1590	<	assertEquals(0, p.getActiveThreadCount());
1591	<	assertEquals(0, p.getQueuedTaskCount());
1592	<	assertEquals(0, p.getQueuedSubmissionCount());
1593	<	assertFalse(p.hasQueuedSubmissions());
1594	<	assertFalse(p.isShutdown());
1595	<	assertFalse(p.isTerminating());
1596	<	assertFalse(p.isTerminated());
1597	<	break;
1598	<	}
1555	>	final long startTime = System.nanoTime();
1556	>	ForkJoinTask a = new CheckedRecursiveAction() {
1557	>	protected void realCompute() {
1558	>	FibAction f = new FibAction(8);
1559	>	assertSame(f, f.fork());
1560	>	while (!f.isDone()
1561	>	&& millisElapsedSince(startTime) < LONG_DELAY_MS) {
1562	>	assertFalse(p.getAsyncMode());
1563	>	assertFalse(p.isShutdown());
1564	>	assertFalse(p.isTerminating());
1565	>	assertFalse(p.isTerminated());
1566	>	Thread.yield();
1567	>	}
1568	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1569	>	assertEquals(0, ForkJoinTask.getQueuedTaskCount());
1570	>	assertEquals(21, f.result);
1571	>	}};
1572	>	p.execute(a);
1573	>	assertTrue(p.awaitQuiescence(LONG_DELAY_MS, MILLISECONDS));
1574	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1575	>	assertTrue(p.isQuiescent());
1576	>	assertTrue(a.isDone());
1577	>	assertEquals(0, p.getQueuedTaskCount());
1578	>	assertFalse(p.getAsyncMode());
1579	>	assertEquals(0, p.getActiveThreadCount());
1580	>	assertEquals(0, p.getQueuedTaskCount());
1581	>	assertEquals(0, p.getQueuedSubmissionCount());
1582	>	assertFalse(p.hasQueuedSubmissions());
1583	>	assertFalse(p.isShutdown());
1584	>	assertFalse(p.isTerminating());
1585	>	assertFalse(p.isTerminated());
1586		} finally {
1587		joinPool(p);
1588		}

Diff Legend

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