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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.54 by jsr166, Fri Sep 4 19:35:46 2015 UTC vs.
Revision 1.77 by jsr166, Sun Oct 4 02:07:32 2015 UTC

# Line 15 | Line 15 | import java.util.List;
15   import java.util.concurrent.ArrayBlockingQueue;
16   import java.util.concurrent.BlockingQueue;
17   import java.util.concurrent.Callable;
18 + import java.util.concurrent.CancellationException;
19   import java.util.concurrent.CountDownLatch;
20   import java.util.concurrent.ExecutionException;
21   import java.util.concurrent.Executors;
# Line 28 | Line 29 | import java.util.concurrent.SynchronousQ
29   import java.util.concurrent.ThreadFactory;
30   import java.util.concurrent.ThreadPoolExecutor;
31   import java.util.concurrent.TimeUnit;
32 + import java.util.concurrent.atomic.AtomicInteger;
33  
34   import junit.framework.Test;
35   import junit.framework.TestSuite;
# Line 130 | Line 132 | public class ThreadPoolExecutorTest exte
132       */
133      public void testPrestartCoreThread() {
134          final ThreadPoolExecutor p =
135 <            new ThreadPoolExecutor(2, 2,
135 >            new ThreadPoolExecutor(2, 6,
136                                     LONG_DELAY_MS, MILLISECONDS,
137                                     new ArrayBlockingQueue<Runnable>(10));
138 <        assertEquals(0, p.getPoolSize());
139 <        assertTrue(p.prestartCoreThread());
140 <        assertEquals(1, p.getPoolSize());
141 <        assertTrue(p.prestartCoreThread());
142 <        assertEquals(2, p.getPoolSize());
143 <        assertFalse(p.prestartCoreThread());
144 <        assertEquals(2, p.getPoolSize());
145 <        joinPool(p);
138 >        try (PoolCleaner cleaner = cleaner(p)) {
139 >            assertEquals(0, p.getPoolSize());
140 >            assertTrue(p.prestartCoreThread());
141 >            assertEquals(1, p.getPoolSize());
142 >            assertTrue(p.prestartCoreThread());
143 >            assertEquals(2, p.getPoolSize());
144 >            assertFalse(p.prestartCoreThread());
145 >            assertEquals(2, p.getPoolSize());
146 >            p.setCorePoolSize(4);
147 >            assertTrue(p.prestartCoreThread());
148 >            assertEquals(3, p.getPoolSize());
149 >            assertTrue(p.prestartCoreThread());
150 >            assertEquals(4, p.getPoolSize());
151 >            assertFalse(p.prestartCoreThread());
152 >            assertEquals(4, p.getPoolSize());
153 >        }
154      }
155  
156      /**
# Line 148 | Line 158 | public class ThreadPoolExecutorTest exte
158       */
159      public void testPrestartAllCoreThreads() {
160          final ThreadPoolExecutor p =
161 <            new ThreadPoolExecutor(2, 2,
161 >            new ThreadPoolExecutor(2, 6,
162                                     LONG_DELAY_MS, MILLISECONDS,
163                                     new ArrayBlockingQueue<Runnable>(10));
164 <        assertEquals(0, p.getPoolSize());
165 <        p.prestartAllCoreThreads();
166 <        assertEquals(2, p.getPoolSize());
167 <        p.prestartAllCoreThreads();
168 <        assertEquals(2, p.getPoolSize());
169 <        joinPool(p);
164 >        try (PoolCleaner cleaner = cleaner(p)) {
165 >            assertEquals(0, p.getPoolSize());
166 >            p.prestartAllCoreThreads();
167 >            assertEquals(2, p.getPoolSize());
168 >            p.prestartAllCoreThreads();
169 >            assertEquals(2, p.getPoolSize());
170 >            p.setCorePoolSize(4);
171 >            p.prestartAllCoreThreads();
172 >            assertEquals(4, p.getPoolSize());
173 >            p.prestartAllCoreThreads();
174 >            assertEquals(4, p.getPoolSize());
175 >        }
176      }
177  
178      /**
# Line 168 | Line 184 | public class ThreadPoolExecutorTest exte
184              new ThreadPoolExecutor(2, 2,
185                                     LONG_DELAY_MS, MILLISECONDS,
186                                     new ArrayBlockingQueue<Runnable>(10));
187 <        final CountDownLatch threadStarted = new CountDownLatch(1);
188 <        final CountDownLatch threadProceed = new CountDownLatch(1);
189 <        final CountDownLatch threadDone = new CountDownLatch(1);
190 <        try {
187 >        try (PoolCleaner cleaner = cleaner(p)) {
188 >            final CountDownLatch threadStarted = new CountDownLatch(1);
189 >            final CountDownLatch threadProceed = new CountDownLatch(1);
190 >            final CountDownLatch threadDone = new CountDownLatch(1);
191              assertEquals(0, p.getCompletedTaskCount());
192              p.execute(new CheckedRunnable() {
193                  public void realRun() throws InterruptedException {
# Line 190 | Line 206 | public class ThreadPoolExecutorTest exte
206                      fail("timed out");
207                  Thread.yield();
208              }
193 –        } finally {
194 –            joinPool(p);
209          }
210      }
211  
# Line 203 | Line 217 | public class ThreadPoolExecutorTest exte
217              new ThreadPoolExecutor(1, 1,
218                                     LONG_DELAY_MS, MILLISECONDS,
219                                     new ArrayBlockingQueue<Runnable>(10));
220 <        assertEquals(1, p.getCorePoolSize());
221 <        joinPool(p);
220 >        try (PoolCleaner cleaner = cleaner(p)) {
221 >            assertEquals(1, p.getCorePoolSize());
222 >        }
223      }
224  
225      /**
# Line 215 | Line 230 | public class ThreadPoolExecutorTest exte
230              new ThreadPoolExecutor(2, 2,
231                                     1000, MILLISECONDS,
232                                     new ArrayBlockingQueue<Runnable>(10));
233 <        assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS));
234 <        joinPool(p);
233 >        try (PoolCleaner cleaner = cleaner(p)) {
234 >            assertEquals(1, p.getKeepAliveTime(SECONDS));
235 >        }
236      }
237  
238      /**
239       * getThreadFactory returns factory in constructor if not set
240       */
241      public void testGetThreadFactory() {
242 <        ThreadFactory tf = new SimpleThreadFactory();
242 >        ThreadFactory threadFactory = new SimpleThreadFactory();
243          final ThreadPoolExecutor p =
244              new ThreadPoolExecutor(1, 2,
245                                     LONG_DELAY_MS, MILLISECONDS,
246                                     new ArrayBlockingQueue<Runnable>(10),
247 <                                   tf,
247 >                                   threadFactory,
248                                     new NoOpREHandler());
249 <        assertSame(tf, p.getThreadFactory());
250 <        joinPool(p);
249 >        try (PoolCleaner cleaner = cleaner(p)) {
250 >            assertSame(threadFactory, p.getThreadFactory());
251 >        }
252      }
253  
254      /**
# Line 242 | Line 259 | public class ThreadPoolExecutorTest exte
259              new ThreadPoolExecutor(1, 2,
260                                     LONG_DELAY_MS, MILLISECONDS,
261                                     new ArrayBlockingQueue<Runnable>(10));
262 <        ThreadFactory tf = new SimpleThreadFactory();
263 <        p.setThreadFactory(tf);
264 <        assertSame(tf, p.getThreadFactory());
265 <        joinPool(p);
262 >        try (PoolCleaner cleaner = cleaner(p)) {
263 >            ThreadFactory threadFactory = new SimpleThreadFactory();
264 >            p.setThreadFactory(threadFactory);
265 >            assertSame(threadFactory, p.getThreadFactory());
266 >        }
267      }
268  
269      /**
# Line 256 | Line 274 | public class ThreadPoolExecutorTest exte
274              new ThreadPoolExecutor(1, 2,
275                                     LONG_DELAY_MS, MILLISECONDS,
276                                     new ArrayBlockingQueue<Runnable>(10));
277 <        try {
278 <            p.setThreadFactory(null);
279 <            shouldThrow();
280 <        } catch (NullPointerException success) {
281 <        } finally {
264 <            joinPool(p);
277 >        try (PoolCleaner cleaner = cleaner(p)) {
278 >            try {
279 >                p.setThreadFactory(null);
280 >                shouldThrow();
281 >            } catch (NullPointerException success) {}
282          }
283      }
284  
# Line 269 | Line 286 | public class ThreadPoolExecutorTest exte
286       * getRejectedExecutionHandler returns handler in constructor if not set
287       */
288      public void testGetRejectedExecutionHandler() {
289 <        final RejectedExecutionHandler h = new NoOpREHandler();
289 >        final RejectedExecutionHandler handler = new NoOpREHandler();
290          final ThreadPoolExecutor p =
291              new ThreadPoolExecutor(1, 2,
292                                     LONG_DELAY_MS, MILLISECONDS,
293                                     new ArrayBlockingQueue<Runnable>(10),
294 <                                   h);
295 <        assertSame(h, p.getRejectedExecutionHandler());
296 <        joinPool(p);
294 >                                   handler);
295 >        try (PoolCleaner cleaner = cleaner(p)) {
296 >            assertSame(handler, p.getRejectedExecutionHandler());
297 >        }
298      }
299  
300      /**
# Line 288 | Line 306 | public class ThreadPoolExecutorTest exte
306              new ThreadPoolExecutor(1, 2,
307                                     LONG_DELAY_MS, MILLISECONDS,
308                                     new ArrayBlockingQueue<Runnable>(10));
309 <        RejectedExecutionHandler h = new NoOpREHandler();
310 <        p.setRejectedExecutionHandler(h);
311 <        assertSame(h, p.getRejectedExecutionHandler());
312 <        joinPool(p);
309 >        try (PoolCleaner cleaner = cleaner(p)) {
310 >            RejectedExecutionHandler handler = new NoOpREHandler();
311 >            p.setRejectedExecutionHandler(handler);
312 >            assertSame(handler, p.getRejectedExecutionHandler());
313 >        }
314      }
315  
316      /**
# Line 302 | Line 321 | public class ThreadPoolExecutorTest exte
321              new ThreadPoolExecutor(1, 2,
322                                     LONG_DELAY_MS, MILLISECONDS,
323                                     new ArrayBlockingQueue<Runnable>(10));
324 <        try {
325 <            p.setRejectedExecutionHandler(null);
326 <            shouldThrow();
327 <        } catch (NullPointerException success) {
328 <        } finally {
310 <            joinPool(p);
324 >        try (PoolCleaner cleaner = cleaner(p)) {
325 >            try {
326 >                p.setRejectedExecutionHandler(null);
327 >                shouldThrow();
328 >            } catch (NullPointerException success) {}
329          }
330      }
331  
# Line 321 | Line 339 | public class ThreadPoolExecutorTest exte
339              new ThreadPoolExecutor(THREADS, THREADS,
340                                     LONG_DELAY_MS, MILLISECONDS,
341                                     new ArrayBlockingQueue<Runnable>(10));
342 <        final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
343 <        final CountDownLatch done = new CountDownLatch(1);
344 <        try {
342 >        try (PoolCleaner cleaner = cleaner(p)) {
343 >            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
344 >            final CountDownLatch done = new CountDownLatch(1);
345              assertEquals(0, p.getLargestPoolSize());
346              for (int i = 0; i < THREADS; i++)
347                  p.execute(new CheckedRunnable() {
# Line 332 | Line 350 | public class ThreadPoolExecutorTest exte
350                          done.await();
351                          assertEquals(THREADS, p.getLargestPoolSize());
352                      }});
353 <            assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
336 <            assertEquals(THREADS, p.getLargestPoolSize());
337 <        } finally {
338 <            done.countDown();
339 <            joinPool(p);
353 >            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
354              assertEquals(THREADS, p.getLargestPoolSize());
355 +            done.countDown();   // release pool
356          }
357 +        assertEquals(THREADS, p.getLargestPoolSize());
358      }
359  
360      /**
# Line 350 | Line 366 | public class ThreadPoolExecutorTest exte
366              new ThreadPoolExecutor(2, 3,
367                                     LONG_DELAY_MS, MILLISECONDS,
368                                     new ArrayBlockingQueue<Runnable>(10));
369 <        assertEquals(3, p.getMaximumPoolSize());
370 <        joinPool(p);
369 >        try (PoolCleaner cleaner = cleaner(p)) {
370 >            assertEquals(3, p.getMaximumPoolSize());
371 >            p.setMaximumPoolSize(5);
372 >            assertEquals(5, p.getMaximumPoolSize());
373 >            p.setMaximumPoolSize(4);
374 >            assertEquals(4, p.getMaximumPoolSize());
375 >        }
376      }
377  
378      /**
# Line 623 | Line 644 | public class ThreadPoolExecutorTest exte
644      }
645  
646      /**
647 <     * shutdownNow returns a list containing tasks that were not run
647 >     * shutdownNow returns a list containing tasks that were not run,
648 >     * and those tasks are drained from the queue
649       */
650 <    public void testShutdownNow() {
650 >    public void testShutdownNow() throws InterruptedException {
651 >        final int poolSize = 2;
652 >        final int count = 5;
653 >        final AtomicInteger ran = new AtomicInteger(0);
654          final ThreadPoolExecutor p =
655 <            new ThreadPoolExecutor(1, 1,
655 >            new ThreadPoolExecutor(poolSize, poolSize,
656                                     LONG_DELAY_MS, MILLISECONDS,
657                                     new ArrayBlockingQueue<Runnable>(10));
658 <        List l;
659 <        try {
660 <            for (int i = 0; i < 5; i++)
636 <                p.execute(new MediumPossiblyInterruptedRunnable());
637 <        }
638 <        finally {
658 >        CountDownLatch threadsStarted = new CountDownLatch(poolSize);
659 >        Runnable waiter = new CheckedRunnable() { public void realRun() {
660 >            threadsStarted.countDown();
661              try {
662 <                l = p.shutdownNow();
663 <            } catch (SecurityException ok) { return; }
662 >                MILLISECONDS.sleep(2 * LONG_DELAY_MS);
663 >            } catch (InterruptedException success) {}
664 >            ran.getAndIncrement();
665 >        }};
666 >        for (int i = 0; i < count; i++)
667 >            p.execute(waiter);
668 >        assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
669 >        assertEquals(poolSize, p.getActiveCount());
670 >        assertEquals(0, p.getCompletedTaskCount());
671 >        final List<Runnable> queuedTasks;
672 >        try {
673 >            queuedTasks = p.shutdownNow();
674 >        } catch (SecurityException ok) {
675 >            return; // Allowed in case test doesn't have privs
676          }
677          assertTrue(p.isShutdown());
678 <        assertTrue(l.size() <= 4);
678 >        assertTrue(p.getQueue().isEmpty());
679 >        assertEquals(count - poolSize, queuedTasks.size());
680 >        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
681 >        assertTrue(p.isTerminated());
682 >        assertEquals(poolSize, ran.get());
683 >        assertEquals(poolSize, p.getCompletedTaskCount());
684      }
685  
686      // Exception Tests
# Line 990 | Line 1029 | public class ThreadPoolExecutorTest exte
1029      public void testInterruptedSubmit() throws InterruptedException {
1030          final ThreadPoolExecutor p =
1031              new ThreadPoolExecutor(1, 1,
1032 <                                   60, TimeUnit.SECONDS,
1032 >                                   60, SECONDS,
1033                                     new ArrayBlockingQueue<Runnable>(10));
1034  
1035          final CountDownLatch threadStarted = new CountDownLatch(1);
# Line 1874 | Line 1913 | public class ThreadPoolExecutorTest exte
1913              l.add(new StringTask());
1914              l.add(new StringTask());
1915              List<Future<String>> futures =
1916 <                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1916 >                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1917              assertEquals(2, futures.size());
1918              for (Future<String> future : futures)
1919                  assertSame(TEST_STRING, future.get());
# Line 1892 | Line 1931 | public class ThreadPoolExecutorTest exte
1931                                     LONG_DELAY_MS, MILLISECONDS,
1932                                     new ArrayBlockingQueue<Runnable>(10));
1933          try {
1934 <            List<Callable<String>> l = new ArrayList<Callable<String>>();
1935 <            l.add(new StringTask());
1936 <            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1937 <            l.add(new StringTask());
1938 <            List<Future<String>> futures =
1939 <                e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1940 <            assertEquals(l.size(), futures.size());
1941 <            for (Future future : futures)
1942 <                assertTrue(future.isDone());
1943 <            assertFalse(futures.get(0).isCancelled());
1944 <            assertTrue(futures.get(1).isCancelled());
1934 >            for (long timeout = timeoutMillis();;) {
1935 >                List<Callable<String>> tasks = new ArrayList<>();
1936 >                tasks.add(new StringTask("0"));
1937 >                tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1938 >                tasks.add(new StringTask("2"));
1939 >                long startTime = System.nanoTime();
1940 >                List<Future<String>> futures =
1941 >                    e.invokeAll(tasks, timeout, MILLISECONDS);
1942 >                assertEquals(tasks.size(), futures.size());
1943 >                assertTrue(millisElapsedSince(startTime) >= timeout);
1944 >                for (Future future : futures)
1945 >                    assertTrue(future.isDone());
1946 >                assertTrue(futures.get(1).isCancelled());
1947 >                try {
1948 >                    assertEquals("0", futures.get(0).get());
1949 >                    assertEquals("2", futures.get(2).get());
1950 >                    break;
1951 >                } catch (CancellationException retryWithLongerTimeout) {
1952 >                    timeout *= 2;
1953 >                    if (timeout >= LONG_DELAY_MS / 2)
1954 >                        fail("expected exactly one task to be cancelled");
1955 >                }
1956 >            }
1957          } finally {
1958              joinPool(e);
1959          }
# Line 1948 | Line 1999 | public class ThreadPoolExecutorTest exte
1999       * allowCoreThreadTimeOut(true) causes idle threads to time out
2000       */
2001      public void testAllowCoreThreadTimeOut_true() throws Exception {
2002 <        long coreThreadTimeOut = SHORT_DELAY_MS;
2002 >        long keepAliveTime = timeoutMillis();
2003          final ThreadPoolExecutor p =
2004              new ThreadPoolExecutor(2, 10,
2005 <                                   coreThreadTimeOut, MILLISECONDS,
2005 >                                   keepAliveTime, MILLISECONDS,
2006                                     new ArrayBlockingQueue<Runnable>(10));
2007          final CountDownLatch threadStarted = new CountDownLatch(1);
2008          try {
# Line 1962 | Line 2013 | public class ThreadPoolExecutorTest exte
2013                      assertEquals(1, p.getPoolSize());
2014                  }});
2015              await(threadStarted);
2016 <            delay(coreThreadTimeOut);
2016 >            delay(keepAliveTime);
2017              long startTime = System.nanoTime();
2018              while (p.getPoolSize() > 0
2019                     && millisElapsedSince(startTime) < LONG_DELAY_MS)
# Line 1978 | Line 2029 | public class ThreadPoolExecutorTest exte
2029       * allowCoreThreadTimeOut(false) causes idle threads not to time out
2030       */
2031      public void testAllowCoreThreadTimeOut_false() throws Exception {
2032 <        long coreThreadTimeOut = SHORT_DELAY_MS;
2032 >        long keepAliveTime = timeoutMillis();
2033          final ThreadPoolExecutor p =
2034              new ThreadPoolExecutor(2, 10,
2035 <                                   coreThreadTimeOut, MILLISECONDS,
2035 >                                   keepAliveTime, MILLISECONDS,
2036                                     new ArrayBlockingQueue<Runnable>(10));
2037          final CountDownLatch threadStarted = new CountDownLatch(1);
2038          try {
# Line 1991 | Line 2042 | public class ThreadPoolExecutorTest exte
2042                      threadStarted.countDown();
2043                      assertTrue(p.getPoolSize() >= 1);
2044                  }});
2045 <            delay(2 * coreThreadTimeOut);
2045 >            delay(2 * keepAliveTime);
2046              assertTrue(p.getPoolSize() >= 1);
2047          } finally {
2048              joinPool(p);
# Line 2010 | Line 2061 | public class ThreadPoolExecutorTest exte
2061                  done.countDown();
2062              }};
2063          final ThreadPoolExecutor p =
2064 <            new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2064 >            new ThreadPoolExecutor(1, 30,
2065 >                                   60, SECONDS,
2066                                     new ArrayBlockingQueue(30));
2067          try {
2068              for (int i = 0; i < nTasks; ++i) {
# Line 2029 | Line 2081 | public class ThreadPoolExecutorTest exte
2081          }
2082      }
2083  
2084 +    /**
2085 +     * get(cancelled task) throws CancellationException
2086 +     */
2087 +    public void testGet_cancelled() throws Exception {
2088 +        final ExecutorService e =
2089 +            new ThreadPoolExecutor(1, 1,
2090 +                                   LONG_DELAY_MS, MILLISECONDS,
2091 +                                   new LinkedBlockingQueue<Runnable>());
2092 +        try {
2093 +            final CountDownLatch blockerStarted = new CountDownLatch(1);
2094 +            final CountDownLatch done = new CountDownLatch(1);
2095 +            final List<Future<?>> futures = new ArrayList<>();
2096 +            for (int i = 0; i < 2; i++) {
2097 +                Runnable r = new CheckedRunnable() { public void realRun()
2098 +                                                         throws Throwable {
2099 +                    blockerStarted.countDown();
2100 +                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2101 +                }};
2102 +                futures.add(e.submit(r));
2103 +            }
2104 +            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2105 +            for (Future<?> future : futures) future.cancel(false);
2106 +            for (Future<?> future : futures) {
2107 +                try {
2108 +                    future.get();
2109 +                    shouldThrow();
2110 +                } catch (CancellationException success) {}
2111 +                try {
2112 +                    future.get(LONG_DELAY_MS, MILLISECONDS);
2113 +                    shouldThrow();
2114 +                } catch (CancellationException success) {}
2115 +                assertTrue(future.isCancelled());
2116 +                assertTrue(future.isDone());
2117 +            }
2118 +            done.countDown();
2119 +        } finally {
2120 +            joinPool(e);
2121 +        }
2122 +    }
2123 +
2124   }

Diff Legend

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