ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java (file contents):
Revision 1.82 by jsr166, Sun Oct 4 07:23:20 2015 UTC vs.
Revision 1.96 by jsr166, Wed Aug 24 22:22:39 2016 UTC

#	Line 17 | Line 17 | import java.util.concurrent.Callable;
17		import java.util.concurrent.CancellationException;
18		import java.util.concurrent.CountDownLatch;
19		import java.util.concurrent.ExecutionException;
20	–	import java.util.concurrent.Executors;
20		import java.util.concurrent.ExecutorService;
21		import java.util.concurrent.Future;
22		import java.util.concurrent.FutureTask;
#	Line 248 | Line 247 | public class ThreadPoolExecutorSubclassT
247		* thread becomes active
248		*/
249		public void testGetActiveCount() throws InterruptedException {
250	+	final CountDownLatch done = new CountDownLatch(1);
251		final ThreadPoolExecutor p =
252		new CustomTPE(2, 2,
253		LONG_DELAY_MS, MILLISECONDS,
254		new ArrayBlockingQueue<Runnable>(10));
255	<	try (PoolCleaner cleaner = cleaner(p)) {
255	>	try (PoolCleaner cleaner = cleaner(p, done)) {
256		final CountDownLatch threadStarted = new CountDownLatch(1);
257	–	final CountDownLatch done = new CountDownLatch(1);
257		assertEquals(0, p.getActiveCount());
258		p.execute(new CheckedRunnable() {
259		public void realRun() throws InterruptedException {
260		threadStarted.countDown();
261		assertEquals(1, p.getActiveCount());
262	<	done.await();
262	>	await(done);
263		}});
264	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
264	>	await(threadStarted);
265		assertEquals(1, p.getActiveCount());
267	–	done.countDown();
266		}
267		}
268
#	Line 476 | Line 474 | public class ThreadPoolExecutorSubclassT
474		*/
475		public void testGetLargestPoolSize() throws InterruptedException {
476		final int THREADS = 3;
477	+	final CountDownLatch done = new CountDownLatch(1);
478		final ThreadPoolExecutor p =
479		new CustomTPE(THREADS, THREADS,
480		LONG_DELAY_MS, MILLISECONDS,
481		new ArrayBlockingQueue<Runnable>(10));
482	<	try (PoolCleaner cleaner = cleaner(p)) {
484	<	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
485	<	final CountDownLatch done = new CountDownLatch(1);
482	>	try (PoolCleaner cleaner = cleaner(p, done)) {
483		assertEquals(0, p.getLargestPoolSize());
484	+	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
485		for (int i = 0; i < THREADS; i++)
486		p.execute(new CheckedRunnable() {
487		public void realRun() throws InterruptedException {
488		threadsStarted.countDown();
489	<	done.await();
489	>	await(done);
490		assertEquals(THREADS, p.getLargestPoolSize());
491		}});
492	<	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
492	>	await(threadsStarted);
493		assertEquals(THREADS, p.getLargestPoolSize());
496	–	done.countDown();   // release pool
494		}
495		assertEquals(THREADS, p.getLargestPoolSize());
496		}
#	Line 521 | Line 518 | public class ThreadPoolExecutorSubclassT
518		* become active
519		*/
520		public void testGetPoolSize() throws InterruptedException {
521	+	final CountDownLatch done = new CountDownLatch(1);
522		final ThreadPoolExecutor p =
523		new CustomTPE(1, 1,
524		LONG_DELAY_MS, MILLISECONDS,
525		new ArrayBlockingQueue<Runnable>(10));
526	<	try (PoolCleaner cleaner = cleaner(p)) {
529	<	final CountDownLatch threadStarted = new CountDownLatch(1);
530	<	final CountDownLatch done = new CountDownLatch(1);
526	>	try (PoolCleaner cleaner = cleaner(p, done)) {
527		assertEquals(0, p.getPoolSize());
528	+	final CountDownLatch threadStarted = new CountDownLatch(1);
529		p.execute(new CheckedRunnable() {
530		public void realRun() throws InterruptedException {
531		threadStarted.countDown();
532		assertEquals(1, p.getPoolSize());
533	<	done.await();
533	>	await(done);
534		}});
535	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
535	>	await(threadStarted);
536		assertEquals(1, p.getPoolSize());
540	–	done.countDown();   // release pool
537		}
538		}
539
#	Line 545 | Line 541 | public class ThreadPoolExecutorSubclassT
541		* getTaskCount increases, but doesn't overestimate, when tasks submitted
542		*/
543		public void testGetTaskCount() throws InterruptedException {
544	+	final int TASKS = 3;
545	+	final CountDownLatch done = new CountDownLatch(1);
546		final ThreadPoolExecutor p =
547		new CustomTPE(1, 1,
548		LONG_DELAY_MS, MILLISECONDS,
549		new ArrayBlockingQueue<Runnable>(10));
550	<	try (PoolCleaner cleaner = cleaner(p)) {
550	>	try (PoolCleaner cleaner = cleaner(p, done)) {
551		final CountDownLatch threadStarted = new CountDownLatch(1);
554	–	final CountDownLatch done = new CountDownLatch(1);
552		assertEquals(0, p.getTaskCount());
553	+	assertEquals(0, p.getCompletedTaskCount());
554		p.execute(new CheckedRunnable() {
555		public void realRun() throws InterruptedException {
556		threadStarted.countDown();
557	<	assertEquals(1, p.getTaskCount());
560	<	done.await();
557	>	await(done);
558		}});
559	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
559	>	await(threadStarted);
560		assertEquals(1, p.getTaskCount());
561	<	done.countDown();
561	>	assertEquals(0, p.getCompletedTaskCount());
562	>	for (int i = 0; i < TASKS; i++) {
563	>	assertEquals(1 + i, p.getTaskCount());
564	>	p.execute(new CheckedRunnable() {
565	>	public void realRun() throws InterruptedException {
566	>	threadStarted.countDown();
567	>	assertEquals(1 + TASKS, p.getTaskCount());
568	>	await(done);
569	>	}});
570	>	}
571	>	assertEquals(1 + TASKS, p.getTaskCount());
572	>	assertEquals(0, p.getCompletedTaskCount());
573		}
574	+	assertEquals(1 + TASKS, p.getTaskCount());
575	+	assertEquals(1 + TASKS, p.getCompletedTaskCount());
576		}
577
578		/**
#	Line 596 | Line 606 | public class ThreadPoolExecutorSubclassT
606		public void realRun() throws InterruptedException {
607		assertFalse(p.isTerminating());
608		threadStarted.countDown();
609	<	done.await();
609	>	await(done);
610		}});
611	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
611	>	await(threadStarted);
612		assertFalse(p.isTerminating());
613		done.countDown();
614		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 624 | Line 634 | public class ThreadPoolExecutorSubclassT
634		public void realRun() throws InterruptedException {
635		assertFalse(p.isTerminating());
636		threadStarted.countDown();
637	<	done.await();
637	>	await(done);
638		}});
639	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
639	>	await(threadStarted);
640		assertFalse(p.isTerminating());
641		done.countDown();
642		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 640 | Line 650 | public class ThreadPoolExecutorSubclassT
650		* getQueue returns the work queue, which contains queued tasks
651		*/
652		public void testGetQueue() throws InterruptedException {
653	+	final CountDownLatch done = new CountDownLatch(1);
654		final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
655		final ThreadPoolExecutor p =
656		new CustomTPE(1, 1,
657		LONG_DELAY_MS, MILLISECONDS,
658		q);
659	<	try (PoolCleaner cleaner = cleaner(p)) {
659	>	try (PoolCleaner cleaner = cleaner(p, done)) {
660		final CountDownLatch threadStarted = new CountDownLatch(1);
650	–	final CountDownLatch done = new CountDownLatch(1);
661		FutureTask[] tasks = new FutureTask[5];
662		for (int i = 0; i < tasks.length; i++) {
663		Callable task = new CheckedCallable<Boolean>() {
664		public Boolean realCall() throws InterruptedException {
665		threadStarted.countDown();
666		assertSame(q, p.getQueue());
667	<	done.await();
667	>	await(done);
668		return Boolean.TRUE;
669		}};
670		tasks[i] = new FutureTask(task);
671		p.execute(tasks[i]);
672		}
673	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
673	>	await(threadStarted);
674		assertSame(q, p.getQueue());
675		assertFalse(q.contains(tasks[0]));
676		assertTrue(q.contains(tasks[tasks.length - 1]));
677		assertEquals(tasks.length - 1, q.size());
668	–	done.countDown();
678		}
679		}
680
#	Line 673 | Line 682 | public class ThreadPoolExecutorSubclassT
682		* remove(task) removes queued task, and fails to remove active task
683		*/
684		public void testRemove() throws InterruptedException {
685	+	final CountDownLatch done = new CountDownLatch(1);
686		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
687		final ThreadPoolExecutor p =
688		new CustomTPE(1, 1,
689		LONG_DELAY_MS, MILLISECONDS,
690		q);
691	<	try (PoolCleaner cleaner = cleaner(p)) {
691	>	try (PoolCleaner cleaner = cleaner(p, done)) {
692		Runnable[] tasks = new Runnable[6];
693		final CountDownLatch threadStarted = new CountDownLatch(1);
684	–	final CountDownLatch done = new CountDownLatch(1);
694		for (int i = 0; i < tasks.length; i++) {
695		tasks[i] = new CheckedRunnable() {
696		public void realRun() throws InterruptedException {
697		threadStarted.countDown();
698	<	done.await();
698	>	await(done);
699		}};
700		p.execute(tasks[i]);
701		}
702	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
702	>	await(threadStarted);
703		assertFalse(p.remove(tasks[0]));
704		assertTrue(q.contains(tasks[4]));
705		assertTrue(q.contains(tasks[3]));
#	Line 700 | Line 709 | public class ThreadPoolExecutorSubclassT
709		assertTrue(q.contains(tasks[3]));
710		assertTrue(p.remove(tasks[3]));
711		assertFalse(q.contains(tasks[3]));
703	–	done.countDown();
712		}
713		}
714
#	Line 715 | Line 723 | public class ThreadPoolExecutorSubclassT
723		new CustomTPE(1, 1,
724		LONG_DELAY_MS, MILLISECONDS,
725		q);
726	<	try (PoolCleaner cleaner = cleaner(p)) {
726	>	try (PoolCleaner cleaner = cleaner(p, done)) {
727		FutureTask[] tasks = new FutureTask[5];
728		for (int i = 0; i < tasks.length; i++) {
729		Callable task = new CheckedCallable<Boolean>() {
730		public Boolean realCall() throws InterruptedException {
731		threadStarted.countDown();
732	<	done.await();
732	>	await(done);
733		return Boolean.TRUE;
734		}};
735		tasks[i] = new FutureTask(task);
736		p.execute(tasks[i]);
737		}
738	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
738	>	await(threadStarted);
739		assertEquals(tasks.length, p.getTaskCount());
740		assertEquals(tasks.length - 1, q.size());
741		assertEquals(1L, p.getActiveCount());
#	Line 740 | Line 748 | public class ThreadPoolExecutorSubclassT
748		p.purge();         // Nothing to do
749		assertEquals(tasks.length - 3, q.size());
750		assertEquals(tasks.length - 2, p.getTaskCount());
743	–	done.countDown();
751		}
752		}
753
#	Line 756 | Line 763 | public class ThreadPoolExecutorSubclassT
763		new CustomTPE(poolSize, poolSize,
764		LONG_DELAY_MS, MILLISECONDS,
765		new ArrayBlockingQueue<Runnable>(10));
766	<	CountDownLatch threadsStarted = new CountDownLatch(poolSize);
766	>	final CountDownLatch threadsStarted = new CountDownLatch(poolSize);
767		Runnable waiter = new CheckedRunnable() { public void realRun() {
768		threadsStarted.countDown();
769		try {
#	Line 766 | Line 773 | public class ThreadPoolExecutorSubclassT
773		}};
774		for (int i = 0; i < count; i++)
775		p.execute(waiter);
776	<	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
776	>	await(threadsStarted);
777		assertEquals(poolSize, p.getActiveCount());
778		assertEquals(0, p.getCompletedTaskCount());
779		final List<Runnable> queuedTasks;
#	Line 1125 | Line 1132 | public class ThreadPoolExecutorSubclassT
1132		* execute throws RejectedExecutionException if saturated.
1133		*/
1134		public void testSaturatedExecute() {
1135	+	final CountDownLatch done = new CountDownLatch(1);
1136		final ThreadPoolExecutor p =
1137		new CustomTPE(1, 1,
1138		LONG_DELAY_MS, MILLISECONDS,
1139		new ArrayBlockingQueue<Runnable>(1));
1140	<	try (PoolCleaner cleaner = cleaner(p)) {
1133	<	final CountDownLatch done = new CountDownLatch(1);
1140	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1141		Runnable task = new CheckedRunnable() {
1142		public void realRun() throws InterruptedException {
1143	<	done.await();
1143	>	await(done);
1144		}};
1145		for (int i = 0; i < 2; ++i)
1146		p.execute(task);
#	Line 1144 | Line 1151 | public class ThreadPoolExecutorSubclassT
1151		} catch (RejectedExecutionException success) {}
1152		assertTrue(p.getTaskCount() <= 2);
1153		}
1147	–	done.countDown();
1154		}
1155		}
1156
#	Line 1152 | Line 1158 | public class ThreadPoolExecutorSubclassT
1158		* executor using CallerRunsPolicy runs task if saturated.
1159		*/
1160		public void testSaturatedExecute2() {
1161	+	final CountDownLatch done = new CountDownLatch(1);
1162		final ThreadPoolExecutor p =
1163		new CustomTPE(1, 1,
1164		LONG_DELAY_MS, MILLISECONDS,
1165		new ArrayBlockingQueue<Runnable>(1),
1166		new CustomTPE.CallerRunsPolicy());
1167	<	try (PoolCleaner cleaner = cleaner(p)) {
1161	<	final CountDownLatch done = new CountDownLatch(1);
1167	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1168		Runnable blocker = new CheckedRunnable() {
1169		public void realRun() throws InterruptedException {
1170	<	done.await();
1170	>	await(done);
1171		}};
1172		p.execute(blocker);
1173		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
#	Line 1172 | Line 1178 | public class ThreadPoolExecutorSubclassT
1178		for (int i = 1; i < tasks.length; i++)
1179		assertTrue(tasks[i].done);
1180		assertFalse(tasks[0].done); // waiting in queue
1175	–	done.countDown();
1181		}
1182		}
1183
#	Line 1183 | Line 1188 | public class ThreadPoolExecutorSubclassT
1188		final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1189		for (int i = 0; i < tasks.length; ++i)
1190		tasks[i] = new TrackedNoOpRunnable();
1191	+	final CountDownLatch done = new CountDownLatch(1);
1192		final ThreadPoolExecutor p =
1193		new CustomTPE(1, 1,
1194		LONG_DELAY_MS, MILLISECONDS,
1195		new ArrayBlockingQueue<Runnable>(1),
1196		new CustomTPE.DiscardPolicy());
1197	<	try (PoolCleaner cleaner = cleaner(p)) {
1192	<	final CountDownLatch done = new CountDownLatch(1);
1197	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1198		p.execute(awaiter(done));
1199
1200		for (TrackedNoOpRunnable task : tasks)
1201		p.execute(task);
1202		for (int i = 1; i < tasks.length; i++)
1203		assertFalse(tasks[i].done);
1199	–	done.countDown();
1204		}
1205		for (int i = 1; i < tasks.length; i++)
1206		assertFalse(tasks[i].done);
#	Line 1216 | Line 1220 | public class ThreadPoolExecutorSubclassT
1220		LONG_DELAY_MS, MILLISECONDS,
1221		new ArrayBlockingQueue<Runnable>(1),
1222		new CustomTPE.DiscardOldestPolicy());
1223	<	try (PoolCleaner cleaner = cleaner(p)) {
1223	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1224		assertEquals(LatchAwaiter.NEW, r1.state);
1225		assertEquals(LatchAwaiter.NEW, r2.state);
1226		assertEquals(LatchAwaiter.NEW, r3.state);
#	Line 1226 | Line 1230 | public class ThreadPoolExecutorSubclassT
1230		p.execute(r3);
1231		assertFalse(p.getQueue().contains(r2));
1232		assertTrue(p.getQueue().contains(r3));
1229	–	done.countDown();
1233		}
1234		assertEquals(LatchAwaiter.DONE, r1.state);
1235		assertEquals(LatchAwaiter.NEW, r2.state);
#	Line 1721 | Line 1724 | public class ThreadPoolExecutorSubclassT
1724		LONG_DELAY_MS, MILLISECONDS,
1725		new ArrayBlockingQueue<Runnable>(10));
1726		try (PoolCleaner cleaner = cleaner(e)) {
1727	+	long startTime = System.nanoTime();
1728		List<Callable<String>> l = new ArrayList<Callable<String>>();
1729		l.add(new NPETask());
1730		try {
1731	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1731	>	e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1732		shouldThrow();
1733		} catch (ExecutionException success) {
1734		assertTrue(success.getCause() instanceof NullPointerException);
1735		}
1736	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1737		}
1738		}
1739
#	Line 1741 | Line 1746 | public class ThreadPoolExecutorSubclassT
1746		LONG_DELAY_MS, MILLISECONDS,
1747		new ArrayBlockingQueue<Runnable>(10));
1748		try (PoolCleaner cleaner = cleaner(e)) {
1749	+	long startTime = System.nanoTime();
1750		List<Callable<String>> l = new ArrayList<Callable<String>>();
1751		l.add(new StringTask());
1752		l.add(new StringTask());
1753	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1753	>	String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1754		assertSame(TEST_STRING, result);
1755	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1756		}
1757		}
1758
#	Line 1829 | Line 1836 | public class ThreadPoolExecutorSubclassT
1836		List<Callable<String>> l = new ArrayList<Callable<String>>();
1837		l.add(new NPETask());
1838		List<Future<String>> futures =
1839	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1839	>	e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1840		assertEquals(1, futures.size());
1841		try {
1842		futures.get(0).get();
#	Line 1864 | Line 1871 | public class ThreadPoolExecutorSubclassT
1871		* timed invokeAll(c) cancels tasks not completed by timeout
1872		*/
1873		public void testTimedInvokeAll6() throws Exception {
1874	<	final ExecutorService e =
1875	<	new CustomTPE(2, 2,
1876	<	LONG_DELAY_MS, MILLISECONDS,
1877	<	new ArrayBlockingQueue<Runnable>(10));
1878	<	try (PoolCleaner cleaner = cleaner(e)) {
1879	<	for (long timeout = timeoutMillis();;) {
1874	>	for (long timeout = timeoutMillis();;) {
1875	>	final CountDownLatch done = new CountDownLatch(1);
1876	>	final Callable<String> waiter = new CheckedCallable<String>() {
1877	>	public String realCall() {
1878	>	try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1879	>	catch (InterruptedException ok) {}
1880	>	return "1"; }};
1881	>	final ExecutorService p =
1882	>	new CustomTPE(2, 2,
1883	>	LONG_DELAY_MS, MILLISECONDS,
1884	>	new ArrayBlockingQueue<Runnable>(10));
1885	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1886		List<Callable<String>> tasks = new ArrayList<>();
1887		tasks.add(new StringTask("0"));
1888	<	tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1888	>	tasks.add(waiter);
1889		tasks.add(new StringTask("2"));
1890		long startTime = System.nanoTime();
1891		List<Future<String>> futures =
1892	<	e.invokeAll(tasks, timeout, MILLISECONDS);
1892	>	p.invokeAll(tasks, timeout, MILLISECONDS);
1893		assertEquals(tasks.size(), futures.size());
1894		assertTrue(millisElapsedSince(startTime) >= timeout);
1895		for (Future future : futures)
#	Line 1985 | Line 1998 | public class ThreadPoolExecutorSubclassT
1998		* (in part, a test of CustomTPE itself)
1999		*/
2000		public void testGet_cancelled() throws Exception {
2001	+	final CountDownLatch done = new CountDownLatch(1);
2002		final ExecutorService e =
2003		new CustomTPE(1, 1,
2004		LONG_DELAY_MS, MILLISECONDS,
2005		new LinkedBlockingQueue<Runnable>());
2006	<	try (PoolCleaner cleaner = cleaner(e)) {
2006	>	try (PoolCleaner cleaner = cleaner(e, done)) {
2007		final CountDownLatch blockerStarted = new CountDownLatch(1);
1994	–	final CountDownLatch done = new CountDownLatch(1);
2008		final List<Future<?>> futures = new ArrayList<>();
2009		for (int i = 0; i < 2; i++) {
2010		Runnable r = new CheckedRunnable() { public void realRun()
#	Line 2001 | Line 2014 | public class ThreadPoolExecutorSubclassT
2014		}};
2015		futures.add(e.submit(r));
2016		}
2017	<	assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2017	>	await(blockerStarted);
2018		for (Future<?> future : futures) future.cancel(false);
2019		for (Future<?> future : futures) {
2020		try {
#	Line 2015 | Line 2028 | public class ThreadPoolExecutorSubclassT
2028		assertTrue(future.isCancelled());
2029		assertTrue(future.isDone());
2030		}
2018	–	done.countDown();
2031		}
2032		}
2033

Diff Legend

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