ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java (file contents):
Revision 1.39 by jsr166, Mon Sep 14 03:27:11 2015 UTC vs.
Revision 1.56 by jsr166, Sun Oct 4 01:30:27 2015 UTC

# Line 30 | Line 30 | import java.util.concurrent.ThreadFactor
30   import java.util.concurrent.ThreadPoolExecutor;
31   import java.util.concurrent.TimeoutException;
32   import java.util.concurrent.TimeUnit;
33 + import java.util.concurrent.atomic.AtomicInteger;
34   import java.util.concurrent.locks.Condition;
35   import java.util.concurrent.locks.ReentrantLock;
36  
# Line 100 | Line 101 | public class ThreadPoolExecutorSubclassT
101              }
102              lock.lock();
103              try {
104 <                result = v;
105 <                exception = e;
106 <                done = true;
107 <                thread = null;
108 <                cond.signalAll();
104 >                if (!done) {
105 >                    result = v;
106 >                    exception = e;
107 >                    done = true;
108 >                    thread = null;
109 >                    cond.signalAll();
110 >                }
111              }
112              finally { lock.unlock(); }
113          }
# Line 113 | Line 116 | public class ThreadPoolExecutorSubclassT
116              try {
117                  while (!done)
118                      cond.await();
119 +                if (cancelled)
120 +                    throw new CancellationException();
121                  if (exception != null)
122                      throw new ExecutionException(exception);
123                  return result;
# Line 124 | Line 129 | public class ThreadPoolExecutorSubclassT
129              long nanos = unit.toNanos(timeout);
130              lock.lock();
131              try {
132 <                for (;;) {
133 <                    if (done) break;
129 <                    if (nanos < 0)
132 >                while (!done) {
133 >                    if (nanos <= 0L)
134                          throw new TimeoutException();
135                      nanos = cond.awaitNanos(nanos);
136                  }
137 +                if (cancelled)
138 +                    throw new CancellationException();
139                  if (exception != null)
140                      throw new ExecutionException(exception);
141                  return result;
# Line 226 | Line 232 | public class ThreadPoolExecutorSubclassT
232      public void testExecute() throws InterruptedException {
233          final ThreadPoolExecutor p =
234              new CustomTPE(1, 1,
235 <                          LONG_DELAY_MS, MILLISECONDS,
235 >                          2 * LONG_DELAY_MS, MILLISECONDS,
236                            new ArrayBlockingQueue<Runnable>(10));
237 <        final CountDownLatch done = new CountDownLatch(1);
238 <        final Runnable task = new CheckedRunnable() {
239 <            public void realRun() {
240 <                done.countDown();
235 <            }};
236 <        try {
237 >        try (PoolCleaner cleaner = cleaner(p)) {
238 >            final CountDownLatch done = new CountDownLatch(1);
239 >            final Runnable task = new CheckedRunnable() {
240 >                public void realRun() { done.countDown(); }};
241              p.execute(task);
242 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
239 <        } finally {
240 <            joinPool(p);
242 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
243          }
244      }
245  
# Line 252 | Line 254 | public class ThreadPoolExecutorSubclassT
254                            new ArrayBlockingQueue<Runnable>(10));
255          final CountDownLatch threadStarted = new CountDownLatch(1);
256          final CountDownLatch done = new CountDownLatch(1);
257 <        try {
257 >        try (PoolCleaner cleaner = cleaner(p)) {
258              assertEquals(0, p.getActiveCount());
259              p.execute(new CheckedRunnable() {
260                  public void realRun() throws InterruptedException {
# Line 262 | Line 264 | public class ThreadPoolExecutorSubclassT
264                  }});
265              assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
266              assertEquals(1, p.getActiveCount());
265 –        } finally {
267              done.countDown();
267 –            joinPool(p);
268          }
269      }
270  
# Line 272 | Line 272 | public class ThreadPoolExecutorSubclassT
272       * prestartCoreThread starts a thread if under corePoolSize, else doesn't
273       */
274      public void testPrestartCoreThread() {
275 <        ThreadPoolExecutor p = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
276 <        assertEquals(0, p.getPoolSize());
277 <        assertTrue(p.prestartCoreThread());
278 <        assertEquals(1, p.getPoolSize());
279 <        assertTrue(p.prestartCoreThread());
280 <        assertEquals(2, p.getPoolSize());
281 <        assertFalse(p.prestartCoreThread());
282 <        assertEquals(2, p.getPoolSize());
283 <        joinPool(p);
275 >        ThreadPoolExecutor p =
276 >            new CustomTPE(2, 6,
277 >                          LONG_DELAY_MS, MILLISECONDS,
278 >                          new ArrayBlockingQueue<Runnable>(10));
279 >        try (PoolCleaner cleaner = cleaner(p)) {
280 >            assertEquals(0, p.getPoolSize());
281 >            assertTrue(p.prestartCoreThread());
282 >            assertEquals(1, p.getPoolSize());
283 >            assertTrue(p.prestartCoreThread());
284 >            assertEquals(2, p.getPoolSize());
285 >            assertFalse(p.prestartCoreThread());
286 >            assertEquals(2, p.getPoolSize());
287 >            p.setCorePoolSize(4);
288 >            assertTrue(p.prestartCoreThread());
289 >            assertEquals(3, p.getPoolSize());
290 >            assertTrue(p.prestartCoreThread());
291 >            assertEquals(4, p.getPoolSize());
292 >            assertFalse(p.prestartCoreThread());
293 >            assertEquals(4, p.getPoolSize());
294 >        }
295      }
296  
297      /**
298       * prestartAllCoreThreads starts all corePoolSize threads
299       */
300      public void testPrestartAllCoreThreads() {
301 <        ThreadPoolExecutor p = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
302 <        assertEquals(0, p.getPoolSize());
303 <        p.prestartAllCoreThreads();
304 <        assertEquals(2, p.getPoolSize());
305 <        p.prestartAllCoreThreads();
306 <        assertEquals(2, p.getPoolSize());
307 <        joinPool(p);
301 >        ThreadPoolExecutor p =
302 >            new CustomTPE(2, 6,
303 >                          LONG_DELAY_MS, MILLISECONDS,
304 >                          new ArrayBlockingQueue<Runnable>(10));
305 >        try (PoolCleaner cleaner = cleaner(p)) {
306 >            assertEquals(0, p.getPoolSize());
307 >            p.prestartAllCoreThreads();
308 >            assertEquals(2, p.getPoolSize());
309 >            p.prestartAllCoreThreads();
310 >            assertEquals(2, p.getPoolSize());
311 >            p.setCorePoolSize(4);
312 >            p.prestartAllCoreThreads();
313 >            assertEquals(4, p.getPoolSize());
314 >            p.prestartAllCoreThreads();
315 >            assertEquals(4, p.getPoolSize());
316 >        }
317      }
318  
319      /**
# Line 305 | Line 325 | public class ThreadPoolExecutorSubclassT
325              new CustomTPE(2, 2,
326                            LONG_DELAY_MS, MILLISECONDS,
327                            new ArrayBlockingQueue<Runnable>(10));
328 <        final CountDownLatch threadStarted = new CountDownLatch(1);
329 <        final CountDownLatch threadProceed = new CountDownLatch(1);
330 <        final CountDownLatch threadDone = new CountDownLatch(1);
331 <        try {
328 >        try (PoolCleaner cleaner = cleaner(p)) {
329 >            final CountDownLatch threadStarted = new CountDownLatch(1);
330 >            final CountDownLatch threadProceed = new CountDownLatch(1);
331 >            final CountDownLatch threadDone = new CountDownLatch(1);
332              assertEquals(0, p.getCompletedTaskCount());
333              p.execute(new CheckedRunnable() {
334                  public void realRun() throws InterruptedException {
# Line 327 | Line 347 | public class ThreadPoolExecutorSubclassT
347                      fail("timed out");
348                  Thread.yield();
349              }
330 –        } finally {
331 –            joinPool(p);
350          }
351      }
352  
# Line 336 | Line 354 | public class ThreadPoolExecutorSubclassT
354       * getCorePoolSize returns size given in constructor if not otherwise set
355       */
356      public void testGetCorePoolSize() {
357 <        ThreadPoolExecutor p = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
358 <        assertEquals(1, p.getCorePoolSize());
359 <        joinPool(p);
357 >        ThreadPoolExecutor p =
358 >            new CustomTPE(1, 1,
359 >                          LONG_DELAY_MS, MILLISECONDS,
360 >                          new ArrayBlockingQueue<Runnable>(10));
361 >        try (PoolCleaner cleaner = cleaner(p)) {
362 >            assertEquals(1, p.getCorePoolSize());
363 >        }
364      }
365  
366      /**
367       * getKeepAliveTime returns value given in constructor if not otherwise set
368       */
369      public void testGetKeepAliveTime() {
370 <        ThreadPoolExecutor p = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
371 <        assertEquals(1, p.getKeepAliveTime(SECONDS));
372 <        joinPool(p);
370 >        ThreadPoolExecutor p =
371 >            new CustomTPE(2, 2,
372 >                          1000, MILLISECONDS,
373 >                          new ArrayBlockingQueue<Runnable>(10));
374 >        try (PoolCleaner cleaner = cleaner(p)) {
375 >            assertEquals(1, p.getKeepAliveTime(SECONDS));
376 >        }
377      }
378  
379      /**
# Line 699 | Line 725 | public class ThreadPoolExecutorSubclassT
725      }
726  
727      /**
728 <     * shutdownNow returns a list containing tasks that were not run
728 >     * shutdownNow returns a list containing tasks that were not run,
729 >     * and those tasks are drained from the queue
730       */
731 <    public void testShutdownNow() {
732 <        ThreadPoolExecutor p = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
733 <        List l;
734 <        try {
735 <            for (int i = 0; i < 5; i++)
736 <                p.execute(new MediumPossiblyInterruptedRunnable());
737 <        }
738 <        finally {
731 >    public void testShutdownNow() throws InterruptedException {
732 >        final int poolSize = 2;
733 >        final int count = 5;
734 >        final AtomicInteger ran = new AtomicInteger(0);
735 >        ThreadPoolExecutor p =
736 >            new CustomTPE(poolSize, poolSize, LONG_DELAY_MS, MILLISECONDS,
737 >                          new ArrayBlockingQueue<Runnable>(10));
738 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
739 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
740 >            threadsStarted.countDown();
741              try {
742 <                l = p.shutdownNow();
743 <            } catch (SecurityException ok) { return; }
742 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
743 >            } catch (InterruptedException success) {}
744 >            ran.getAndIncrement();
745 >        }};
746 >        for (int i = 0; i < count; i++)
747 >            p.execute(waiter);
748 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
749 >        assertEquals(poolSize, p.getActiveCount());
750 >        assertEquals(0, p.getCompletedTaskCount());
751 >        final List<Runnable> queuedTasks;
752 >        try {
753 >            queuedTasks = p.shutdownNow();
754 >        } catch (SecurityException ok) {
755 >            return; // Allowed in case test doesn't have privs
756          }
757          assertTrue(p.isShutdown());
758 <        assertTrue(l.size() <= 4);
758 >        assertTrue(p.getQueue().isEmpty());
759 >        assertEquals(count - poolSize, queuedTasks.size());
760 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
761 >        assertTrue(p.isTerminated());
762 >        assertEquals(poolSize, ran.get());
763 >        assertEquals(poolSize, p.getCompletedTaskCount());
764      }
765  
766      // Exception Tests
# Line 1723 | Line 1769 | public class ThreadPoolExecutorSubclassT
1769              l.add(new StringTask());
1770              l.add(new StringTask());
1771              List<Future<String>> futures =
1772 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1772 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1773              assertEquals(2, futures.size());
1774              for (Future<String> future : futures)
1775                  assertSame(TEST_STRING, future.get());
# Line 1853 | Line 1899 | public class ThreadPoolExecutorSubclassT
1899          }
1900      }
1901  
1902 +    /**
1903 +     * get(cancelled task) throws CancellationException
1904 +     * (in part, a test of CustomTPE itself)
1905 +     */
1906 +    public void testGet_cancelled() throws Exception {
1907 +        final ExecutorService e =
1908 +            new CustomTPE(1, 1,
1909 +                          LONG_DELAY_MS, MILLISECONDS,
1910 +                          new LinkedBlockingQueue<Runnable>());
1911 +        try {
1912 +            final CountDownLatch blockerStarted = new CountDownLatch(1);
1913 +            final CountDownLatch done = new CountDownLatch(1);
1914 +            final List<Future<?>> futures = new ArrayList<>();
1915 +            for (int i = 0; i < 2; i++) {
1916 +                Runnable r = new CheckedRunnable() { public void realRun()
1917 +                                                         throws Throwable {
1918 +                    blockerStarted.countDown();
1919 +                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
1920 +                }};
1921 +                futures.add(e.submit(r));
1922 +            }
1923 +            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
1924 +            for (Future<?> future : futures) future.cancel(false);
1925 +            for (Future<?> future : futures) {
1926 +                try {
1927 +                    future.get();
1928 +                    shouldThrow();
1929 +                } catch (CancellationException success) {}
1930 +                try {
1931 +                    future.get(LONG_DELAY_MS, MILLISECONDS);
1932 +                    shouldThrow();
1933 +                } catch (CancellationException success) {}
1934 +                assertTrue(future.isCancelled());
1935 +                assertTrue(future.isDone());
1936 +            }
1937 +            done.countDown();
1938 +        } finally {
1939 +            joinPool(e);
1940 +        }
1941 +    }
1942 +
1943   }

Diff Legend

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